Comments for PublishedState tests

Author: summerhenson

sasdata/fair_database/data/test/test_published_state.py

@@ -31,6 +31,8 @@ def tearDownClass(cls):
 
 
 class TestPublishedStateView(APITestCase):
+    """Test HTTP methods of PublishedStateView."""
+
     @classmethod
     def setUpTestData(cls):
         cls.user1 = User.objects.create_user(
@@ -74,7 +76,7 @@ def setUpTestData(cls):
         cls.auth_client1.force_authenticate(cls.user1)
         cls.auth_client2.force_authenticate(cls.user2)
 
-    # Test listing published states - various permissions
+    # Test listing published states including those of owned private sessions
     def test_list_published_states_private(self):
         request = self.auth_client1.get("/v1/data/published/")
         self.assertEqual(request.status_code, status.HTTP_200_OK)
@@ -101,6 +103,7 @@ def test_list_published_states_private(self):
             },
         )
 
+    # Test listing published states of public sessions
     def test_list_published_states_public(self):
         request = self.auth_client2.get("/v1/data/published/")
         self.assertEqual(request.status_code, status.HTTP_200_OK)
@@ -122,6 +125,7 @@ def test_list_published_states_public(self):
             },
         )
 
+    # Test listing published states including sessions with access granted
     def test_list_published_states_shared(self):
         self.private_session.users.add(self.user2)
         request = self.auth_client2.get("/v1/data/published/")
@@ -150,6 +154,7 @@ def test_list_published_states_shared(self):
             },
         )
 
+    # Test listing published states while unauthenticated
     def test_list_published_states_unauthenticated(self):
         request = self.client.get("/v1/data/published/")
         self.assertEqual(request.status_code, status.HTTP_200_OK)
@@ -171,6 +176,7 @@ def test_list_published_states_unauthenticated(self):
             },
         )
 
+    # Test creating a published state for a private session
     def test_published_state_created_private(self):
         self.unpublished_session.is_public = False
         self.unpublished_session.save()
@@ -198,6 +204,7 @@ def test_published_state_created_private(self):
         self.unpublished_session.is_public = True
         self.unpublished_session.save()
 
+    # Test creating a published state for a public session
     def test_published_state_created_public(self):
         published_state = {"published": False, "session": 4}
         request = self.auth_client1.post("/v1/data/published/", data=published_state)
@@ -221,6 +228,7 @@ def test_published_state_created_public(self):
         self.assertEqual(new_ps.session, self.publishable_session)
         new_ps.delete()
 
+    # Test that you can't create a published state for an unowned session
     def test_published_state_created_unowned(self):
         self.unpublished_session.current_user = None
         self.unpublished_session.save()
@@ -231,29 +239,26 @@ def test_published_state_created_unowned(self):
         self.unpublished_session.current_user = self.user1
         self.unpublished_session.save()
 
+    # Test that an unauthenticated user cannot create a published state
     def test_published_state_created_unauthenticated(self):
         published_state = {"published": True, "session": 4}
         request = self.client.post("/v1/data/published/", data=published_state)
         self.assertEqual(request.status_code, status.HTTP_401_UNAUTHORIZED)
         self.assertEqual(len(PublishedState.objects.all()), 3)
 
+    # Test that a user cannot create a published state for a session they don't own
     def test_published_state_created_unauthorized(self):
         published_state = {"published": True, "session": 4}
         request = self.auth_client2.post("/v1/data/published/", data=published_state)
         self.assertEqual(request.status_code, status.HTTP_403_FORBIDDEN)
         self.assertEqual(len(PublishedState.objects.all()), 3)
 
+    # Test that only one published state can be created per session
     def test_no_duplicate_published_states(self):
         published_state = {"published": True, "session": 1}
         request = self.auth_client1.post("/v1/data/published/", data=published_state)
         self.assertEqual(request.status_code, status.HTTP_400_BAD_REQUEST)
 
-    # Test creating a published state
-
-    # Test can only create a published state for your own sessions
-
-    # Test can't create a second published state for a session
-
     @classmethod
     def tearDownClass(cls):
         cls.public_session.delete()
@@ -264,6 +269,8 @@ def tearDownClass(cls):
 
 
 class TestSinglePublishedStateView(APITestCase):
+    """Test HTTP methods of SinglePublishedStateView."""
+
     @classmethod
     def setUpTestData(cls):
         cls.user1 = User.objects.create_user(
@@ -304,7 +311,7 @@ def setUpTestData(cls):
         cls.auth_client1.force_authenticate(cls.user1)
         cls.auth_client2.force_authenticate(cls.user2)
 
-    # Test viewing a published state - various permissions
+    # Test viewing a published state of a public session
     def test_get_public_published_state(self):
         request1 = self.auth_client2.get("/v1/data/published/1/")
         request2 = self.client.get("/v1/data/published/1/")
@@ -324,6 +331,7 @@ def test_get_public_published_state(self):
         )
         self.assertEqual(request1.data, request2.data)
 
+    # Test viewing a published state of a private session
     def test_get_private_published_state(self):
         request = self.auth_client1.get("/v1/data/published/2/")
         self.assertEqual(request.status_code, status.HTTP_200_OK)
@@ -340,6 +348,7 @@ def test_get_private_published_state(self):
             },
         )
 
+    # Test viewing a published state of an unowned session
     def test_get_unowned_published_state(self):
         request = self.auth_client1.get("/v1/data/published/3/")
         self.assertEqual(request.status_code, status.HTTP_200_OK)
@@ -356,6 +365,7 @@ def test_get_unowned_published_state(self):
             },
         )
 
+    # Test viewing a published state of a session with access granted
     def test_get_shared_published_state(self):
         self.private_session.users.add(self.user2)
         request = self.auth_client2.get("/v1/data/published/2/")
@@ -374,13 +384,14 @@ def test_get_shared_published_state(self):
             },
         )
 
+    # Test a user can't view a published state of a private session they don't own
     def test_get_private_published_state_unauthorized(self):
         request1 = self.client.get("/v1/data/published/2/")
         request2 = self.auth_client2.get("/v1/data/published/2/")
         self.assertEqual(request1.status_code, status.HTTP_401_UNAUTHORIZED)
         self.assertEqual(request2.status_code, status.HTTP_403_FORBIDDEN)
 
-    # Test updating a published state
+    # Test updating a published state of a public session
     def test_update_public_published_state(self):
         request = self.auth_client1.put(
             "/v1/data/published/1/", data={"published": False}
@@ -399,6 +410,7 @@ def test_update_public_published_state(self):
         self.assertFalse(PublishedState.objects.get(id=1).published)
         self.public_ps.save()
 
+    # Test updating a published state of a private session
     def test_update_private_published_state(self):
         request = self.auth_client1.put(
             "/v1/data/published/2/", data={"published": True}
@@ -417,6 +429,7 @@ def test_update_private_published_state(self):
         self.assertTrue(PublishedState.objects.get(id=2).published)
         self.private_ps.save()
 
+    # Test a user can't update the published state of an unowned session
     def test_update_unowned_published_state(self):
         request1 = self.auth_client1.put(
             "/v1/data/published/3/", data={"published": False}
@@ -426,6 +439,7 @@ def test_update_unowned_published_state(self):
         self.assertEqual(request2.status_code, status.HTTP_401_UNAUTHORIZED)
         self.assertTrue(PublishedState.objects.get(id=3).published)
 
+    # Test a user can't update a public published state unauthorized
     def test_update_public_published_state_unauthorized(self):
         request1 = self.auth_client2.put(
             "/v1/data/published/1/", data={"published": False}
@@ -441,6 +455,7 @@ def test_update_public_published_state_unauthorized(self):
         self.assertEqual(request3.status_code, status.HTTP_401_UNAUTHORIZED)
         self.assertTrue(PublishedState.objects.get(id=1).published)
 
+    # Test a user can't update a private published state unauthorized
     def test_update_private_published_state_unauthorized(self):
         request1 = self.auth_client2.put(
             "/v1/data/published/2/", data={"published": True}
@@ -456,7 +471,7 @@ def test_update_private_published_state_unauthorized(self):
         self.assertEqual(request3.status_code, status.HTTP_401_UNAUTHORIZED)
         self.assertFalse(PublishedState.objects.get(id=2).published)
 
-    # Test deleting a published state - session not deleted
+    # Test deleting a published state of a private session
     def test_delete_private_published_state(self):
         request = self.auth_client1.delete("/v1/data/published/2/")
         self.assertEqual(request.status_code, status.HTTP_200_OK)
@@ -470,6 +485,7 @@ def test_delete_private_published_state(self):
             session=self.private_session,
         )
 
+    # Test a user can't delete a private published state unauthorized
     def test_delete_private_published_state_unauthorized(self):
         request1 = self.auth_client2.delete("/v1/data/published/2/")
         self.private_session.users.add(self.user2)
@@ -480,10 +496,12 @@ def test_delete_private_published_state_unauthorized(self):
         self.assertEqual(request2.status_code, status.HTTP_403_FORBIDDEN)
         self.assertEqual(request3.status_code, status.HTTP_401_UNAUTHORIZED)
 
+    # Test a user can't delete a published state of a public
     def test_cant_delete_public_published_state(self):
         request = self.auth_client1.delete("/v1/data/published/1/")
         self.assertEqual(request.status_code, status.HTTP_403_FORBIDDEN)
 
+    # Test a user can't delete an unowned published state
     def test_delete_unowned_published_state(self):
         request = self.auth_client1.delete("/v1/data/published/3/")
         self.assertEqual(request.status_code, status.HTTP_403_FORBIDDEN)