Develop

web/grants/tests.py

@@ -29,7 +29,6 @@ def setUp(self):
             grant_category=self.test_category,
         )
 
-        # This grant will not appear since we filter out grants without points
         self.test_grant_no_point = Grant.objects.create(
             grant="Test Grant No Point",
             title="Test Grant No Point Title",
@@ -38,14 +37,21 @@ def setUp(self):
         )
 
 
-class GrantAPIRouteTests(APITestCase):
+class GrantAPIRouteTests(BaseTestCase):
     def test_grant_list_route_exists(self):
         """
         Ensure Grant List API route exists
         """
         response = self.client.get("/api/grants/", format="json")
         self.assertEqual(response.status_code, status.HTTP_200_OK)
 
+    def test_grant_detail_route_exists(self):
+        """
+        Ensure Grant Detail API route exists
+        """
+        response = self.client.get(f"/api/grants/{self.test_grant.id}/", format="json")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
     def test_grant_category_route_exists(self):
         """
         Ensure Grant Categories List API route exists

web/language/tests/tests_community.py

@@ -3,14 +3,30 @@
 from django.utils import timezone
 from django.contrib.gis.geos import GEOSGeometry
 
-from language.models import Language, Community, CommunityMember, Recording
+from language.models import (
+    Language,
+    Community,
+    CommunityMember,
+    CommunityLanguageStats,
+    Recording,
+)
 from users.models import User, Administrator
 from web.constants import VERIFIED, REJECTED
 
 
 class BaseTestCase(APITestCase):
     def setUp(self):
-        # Create an Admin Type User
+        FAKE_GEOM = """
+            {
+                "type": "Point",
+                "coordinates": [
+                    -126.3482666015625,
+                    54.74840576223716
+                ]
+            }
+        """
+        self.point = GEOSGeometry(FAKE_GEOM)
+
         self.admin_user = User.objects.create(
             username="admin_user",
             first_name="Admin",
@@ -22,7 +38,6 @@ def setUp(self):
         self.admin_user.set_password("password")
         self.admin_user.save()
 
-        # Create a Regular User with no Privileges
         self.regular_user = User.objects.create(
             username="regular_user",
             first_name="Regular",
@@ -32,11 +47,11 @@ def setUp(self):
         self.regular_user.set_password("password")
         self.regular_user.save()
 
-        # Initial Values for Language and Community
         self.test_language = Language.objects.create(name="Global Test Language")
-        self.test_community = Community.objects.create(name="Global Test Community")
+        self.test_community = Community.objects.create(
+            name="Global Test Community", point=FAKE_GEOM
+        )
 
-        # Create a Community Admin for Testing Permissions
         self.community_admin = User.objects.create(
             username="community_admin_user",
             first_name="Community Admin",
@@ -45,33 +60,27 @@ def setUp(self):
         )
         self.community_admin.set_password("password")
         self.community_admin.save()
+
         Administrator.objects.create(
             user=self.community_admin,
             language=self.test_language,
             community=self.test_community,
         )
 
-        FAKE_GEOM = """
-            {
-                "type": "Point",
-                "coordinates": [
-                    -126.3482666015625,
-                    54.74840576223716
-                ]
-            }
-        """
-        self.point = GEOSGeometry(FAKE_GEOM)
-
-
-class CommunityGeoAPITests(BaseTestCase):
-    def setUp(self):
-        super().setUp()
+        # Create a community without a point, which does not show in the list/search APIs
+        self.invalid_community = Community.objects.create(name="Invalid Community")
 
-        self.valid_community = Community.objects.create(
-            name="Valid Community", point=self.point
+        # Create a test stats
+        self.test_stats = CommunityLanguageStats.objects.create(
+            community=self.test_community,
+            language=self.test_language,
+            fluent_speakers=1,
+            semi_speakers=1,
+            active_learners=1,
         )
-        self.invalid_community = Community.objects.create(name="Invalid Community")
 
+
+class CommunityAPIRouteTests(BaseTestCase):
     def test_community_geo_route_exists(self):
         """
         Ensure Community Geo API route exists
@@ -86,6 +95,73 @@ def test_community_search_route_exists(self):
         response = self.client.get("/api/community-search/", format="json")
         self.assertEqual(response.status_code, status.HTTP_200_OK)
 
+    def test_community_list_route_exists(self):
+        """
+        Ensure Community List API route exists
+        """
+        response = self.client.get("/api/community/", format="json")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+    def test_community_list_member_to_verify_route_exists(self):
+        """
+        Ensure Community List Members to Verify API route exists
+        """
+        response = self.client.get(
+            "/api/community/list_member_to_verify/", format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+    def test_community_member_verify_route_exists(self):
+        """
+        Ensure Community Member Verify API route exists
+        """
+        response = self.client.get("/api/community/verify_member/", format="json")
+        self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
+
+    def test_community_member_reject_route_exists(self):
+        """
+        Ensure Community Member Reject API route exists
+        """
+        response = self.client.get("/api/community/reject_member/", format="json")
+        self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
+
+    def test_community_detail_route_exists(self):
+        """
+        Ensure Community Detail API route exists
+        """
+        response = self.client.get(
+            f"/api/community/{self.test_community.id}/", format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+    def test_community_add_audio_route_exists(self):
+        """
+        Ensure Community Add Audio API route exists
+        """
+        self.assertTrue(
+            self.client.login(username="community_admin_user", password="password")
+        )
+        response = self.client.get(
+            f"/api/community/{self.test_community.id}/add_audio/", format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
+
+    def test_stats_list_route_exists(self):
+        """
+        Ensure Stats List API route exists
+        """
+        response = self.client.get("/api/stats/", format="json")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+    def test_stats_detail_route_exists(self):
+        """
+        Ensure Stats Detail API route exists
+        """
+        response = self.client.get(f"/api/stats/{self.test_stats.id}/", format="json")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+
+class CommunityGeoAPITests(BaseTestCase):
     def test_community_geo(self):
         """
         Ensure Community Geo API works
@@ -95,7 +171,7 @@ def test_community_geo(self):
         self.assertEqual(response.status_code, status.HTTP_200_OK)
 
         # By fetching "features" specifically, we're committing
-        # that this API si a GEO Feature API
+        # that this API is a GEO Feature API
         data = response.json().get("features")
 
         # Only count 1 because the 2nd community in setUp() is invalid
@@ -111,9 +187,9 @@ def test_community_search(self):
         data = response.json()
 
         # By fetching the first record, we're committing
-        # that the valid_community was added to the search list
-        valid_community = data[0]
-        self.assertEqual(valid_community.get("name"), "Valid Community")
+        # that the test_community was added to the search list
+        test_community = data[0]
+        self.assertEqual(test_community.get("name"), "Global Test Community")
 
 
 class CommunityAPITests(BaseTestCase):
@@ -149,13 +225,6 @@ def test_community_detail(self):
             response.data["audio_obj"]["recorder"], self.recording.recorder
         )
 
-    def test_community_list_route_exists(self):
-        """
-        Ensure community list API route exists
-        """
-        response = self.client.get("/api/community/", format="json")
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-
     def test_community_add_audio_for_admin(self):
         """
         Ensure we can add a community audio to a community object using an admin account.

web/language/tests/tests_favourite.py

@@ -44,17 +44,41 @@ def setUp(self):
         self.point = GEOSGeometry(self.FAKE_GEOM)
 
 
-class FavouriteAPITests(BaseTestCase):
+class FavouriteAPIRouteTests(BaseTestCase):
     def test_favourite_list_route_exists(self):
         """
         Ensure Favourite list API route exists
         """
-        # Must be logged in
-        self.client.login(username="admin_user", password="password")
+        self.assertTrue(self.client.login(username="admin_user", password="password"))
 
         response = self.client.get("/api/favourite/", format="json")
         self.assertEqual(response.status_code, status.HTTP_200_OK)
 
+    def test_favourite_detail_route_exists(self):
+        """
+        Ensure Favourite Detail API route exists
+        """
+
+        self.assertTrue(self.client.login(username="admin_user", password="password"))
+
+        favourite_placename = Favourite.objects.create(
+            name="Test Favourite Placename",
+            user=self.admin_user,
+            place=self.place,
+            favourite_type="favourite",
+            description="I like this Placename",
+            point=self.point,
+            zoom=10,
+        )
+
+        response = self.client.get(
+            f"/api/favourite/{favourite_placename.id}/", format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+
+class FavouriteAPITests(BaseTestCase):
+
     def test_get_favourite_placename(self):
         """
         Ensure we can retrieve a newly created Favourite object.

web/language/tests/tests_language.py

@@ -9,16 +9,16 @@
 
 class BaseTestCase(APITestCase):
     def setUp(self):
-        self.user = User.objects.create(
-            username="testuser001",
-            first_name="Test",
-            last_name="user 001",
-            email="test@countable.ca",
+        self.admin_user = User.objects.create(
+            username="admin_user",
+            first_name="Admin",
+            last_name="User",
+            email="admin@countable.ca",
             is_staff=True,
             is_superuser=True,
         )
-        self.user.set_password("password")
-        self.user.save()
+        self.admin_user.set_password("password")
+        self.admin_user.save()
 
         self.FAKE_GEOM = """
             {
@@ -45,21 +45,48 @@ def setUp(self):
                 ]
             }"""
 
-
-class CommunityGeoAPITests(BaseTestCase):
-    def setUp(self):
-        super().setUp()
-
         poly = GEOSGeometry(self.FAKE_GEOM)
-        # Only include if it has a geometry
-        self.language1 = Language.objects.create(  # Included (1)
+
+        self.language1 = Language.objects.create(  # With geom
             name="test language1", geom=poly
         )
-        self.language2 = Language.objects.create(  # Exclude
+        self.language2 = Language.objects.create(  # Without geom
             name="test language2",
         )
 
-    # ONE TEST TESTS ONLY ONE SCENARIO ######
+
+class LanguageAPIRouteTests(BaseTestCase):
+    def test_language_list_route_exists(self):
+        """
+        Ensure Language List API route exists
+        """
+        response = self.client.get("/api/language/", format="json")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+    def test_language_detail_route_exists(self):
+        """
+        Ensure Language Detail API route exists
+        """
+        response = self.client.get(f"/api/language/{self.language1.id}/", format="json")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+    def test_language_add_greeting_audio_route_exists(self):
+        """
+        Ensure Language Add Greeting Audio API route exists
+        """
+        response = self.client.get(
+            f"/api/language/{self.language1.id}/add_greeting_audio/", format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
+
+    def test_language_add_language_audio_route_exists(self):
+        """
+        Ensure Language Add Language Audio API route exists
+        """
+        response = self.client.get(
+            f"/api/language/{self.language1.id}/add_language_audio/", format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
 
     def test_language_geo_route_exists(self):
         """
@@ -75,6 +102,10 @@ def test_language_search_route_exists(self):
         response = self.client.get("/api/language-search/", format="json")
         self.assertEqual(response.status_code, status.HTTP_200_OK)
 
+
+class LanguageGeoAPITests(BaseTestCase):
+    # ONE TEST TESTS ONLY ONE SCENARIO ######
+
     def test_language_geo(self):
         """
         Ensure Language Geo API works
@@ -150,7 +181,7 @@ def test_language_add_language_audio(self):
         Ensure we can add a language audio to a language object.
         """
         # Must be logged in
-        self.assertTrue(self.client.login(username="testuser001", password="password"))
+        self.assertTrue(self.client.login(username="admin_user", password="password"))
 
         # Check we're logged in
         response = self.client.get("/api/user/auth/")
@@ -187,7 +218,7 @@ def test_language_add_greeting_audio(self):
         Ensure we can add a greeting audio to a language object.
         """
         # Must be logged in
-        self.assertTrue(self.client.login(username="testuser001", password="password"))
+        self.assertTrue(self.client.login(username="admin_user", password="password"))
 
         # Check we're logged in
         response = self.client.get("/api/user/auth/")