Update Tests For Tag Groups

Signed-off-by: Hassan Abouelela <[email protected]>

3 files changed, 157 insertions, 24 deletions

diff --git a/pydis_site/apps/content/tests/test_utils.py b/pydis_site/apps/content/tests/test_utils.py
index a5d5dcb4..556f633c 100644
--- a/pydis_site/apps/content/tests/test_utils.py
+++ b/pydis_site/apps/content/tests/test_utils.py
@@ -132,6 +132,7 @@ class TagUtilsTests(TestCase):
                 ---
                 This tag has frontmatter!
             """),
+            "This is a grouped tag!",
         )
 
         # Generate a tar archive with a few tags
@@ -146,6 +147,10 @@ class TagUtilsTests(TestCase):
                 (tags_folder / "first_tag.md").write_text(bodies[0])
                 (tags_folder / "second_tag.md").write_text(bodies[1])
 
+                group_folder = tags_folder / "some_group"
+                group_folder.mkdir()
+                (group_folder / "grouped_tag.md").write_text(bodies[2])
+
                 with tarfile.open(tar_folder / "temp.tar", "w") as file:
                     file.add(folder, recursive=True)
 
@@ -158,10 +163,15 @@ class TagUtilsTests(TestCase):
         )
 
         result = utils.fetch_tags()
-        self.assertEqual([
+
+        def sort(_tag: models.Tag) -> str:
+            return _tag.name
+
+        self.assertEqual(sorted([
             models.Tag(name="first_tag", body=bodies[0]),
             models.Tag(name="second_tag", body=bodies[1]),
-        ], sorted(result, key=lambda tag: tag.name))
+            models.Tag(name="grouped_tag", body=bodies[2], group=group_folder.name),
+        ], key=sort), sorted(result, key=sort))
 
     def test_get_real_tag(self):
         """Test that a single tag is returned if it exists."""
@@ -170,30 +180,92 @@ class TagUtilsTests(TestCase):
 
         self.assertEqual(tag, result)
 
+    def test_get_grouped_tag(self):
+        """Test fetching a tag from a group."""
+        tag = models.Tag.objects.create(name="real-tag", group="real-group")
+        result = utils.get_tag("real-group/real-tag")
+
+        self.assertEqual(tag, result)
+
+    def test_get_group(self):
+        """Test fetching a group of tags."""
+        included = [
+            models.Tag.objects.create(name="tag-1", group="real-group"),
+            models.Tag.objects.create(name="tag-2", group="real-group"),
+            models.Tag.objects.create(name="tag-3", group="real-group"),
+        ]
+
+        models.Tag.objects.create(name="not-included-1")
+        models.Tag.objects.create(name="not-included-2", group="other-group")
+
+        result = utils.get_tag("real-group")
+        self.assertListEqual(included, result)
+
     def test_get_tag_404(self):
         """Test that an error is raised when we fetch a non-existing tag."""
         models.Tag.objects.create(name="real-tag")
         with self.assertRaises(models.Tag.DoesNotExist):
             utils.get_tag("fake")
 
-    def test_category_pages(self):
-        """Test that the category pages function returns the correct records for tags."""
-        models.Tag.objects.create(name="second-tag", body="Normal body")
-        models.Tag.objects.create(name="first-tag", body="Normal body")
-        tag_body = {"description": markdown.markdown("Normal body"), "icon": "fas fa-tag"}
-
+    @mock.patch.object(utils, "get_tag_category")
+    def test_category_pages(self, get_mock: mock.Mock):
+        """Test that the category pages function calls the correct method for tags."""
+        tag = models.Tag.objects.create(name="tag")
+        get_mock.return_value = tag
         result = utils.get_category_pages(settings.CONTENT_PAGES_PATH / "tags")
+        self.assertEqual(tag, result)
+        get_mock.assert_called_once_with(collapse_groups=True)
+
+    def test_get_category_root(self):
+        """Test that all tags are returned and formatted properly for the tag root page."""
+        body = "normal body"
+        base = {"description": markdown.markdown(body), "icon": "fas fa-tag"}
+
+        models.Tag.objects.create(name="tag-1", body=body),
+        models.Tag.objects.create(name="tag-2", body=body),
+        models.Tag.objects.create(name="tag-3", body=body),
+
+        models.Tag.objects.create(name="tag-4", body=body, group="tag-group")
+        models.Tag.objects.create(name="tag-5", body=body, group="tag-group")
+
+        result = utils.get_tag_category(collapse_groups=True)
+
         self.assertDictEqual({
-            "first-tag": {**tag_body, "title": "first-tag"},
-            "second-tag": {**tag_body, "title": "second-tag"},
+            "tag-1": {**base, "title": "tag-1"},
+            "tag-2": {**base, "title": "tag-2"},
+            "tag-3": {**base, "title": "tag-3"},
+            "tag-group": {
+                "title": "tag-group",
+                "description": "Contains the following tags: tag-4, tag-5",
+                "icon": "fas fa-tags"
+            }
         }, result)
 
-    def test_trimmed_tag_content(self):
-        """Test a tag with a long body that requires trimming."""
-        tag = models.Tag.objects.create(name="long-tag", body="E" * 300)
-        result = utils.get_category_pages(settings.CONTENT_PAGES_PATH / "tags")
-        self.assertDictEqual({"long-tag": {
-            "title": "long-tag",
-            "description": markdown.markdown(tag.body[:100] + "..."),
-            "icon": "fas fa-tag",
-        }}, result)
+    def test_get_category_group(self):
+        """Test the function for a group root page."""
+        body = "normal body"
+        base = {"description": markdown.markdown(body), "icon": "fas fa-tag"}
+
+        included = [
+            models.Tag.objects.create(name="tag-1", body=body, group="group"),
+            models.Tag.objects.create(name="tag-2", body=body, group="group"),
+        ]
+        models.Tag.objects.create(name="not-included", body=body)
+
+        result = utils.get_tag_category(included, collapse_groups=False)
+        self.assertDictEqual({
+            "tag-1": {**base, "title": "tag-1"},
+            "tag-2": {**base, "title": "tag-2"},
+        }, result)
+
+    def test_tag_url(self):
+        """Test that tag URLs are generated correctly."""
+        cases = [
+            ({"name": "tag"}, f"{models.Tag.URL_BASE}/tag.md"),
+            ({"name": "grouped", "group": "abc"}, f"{models.Tag.URL_BASE}/abc/grouped.md"),
+        ]
+
+        for options, url in cases:
+            tag = models.Tag(**options)
+            with self.subTest(tag=tag):
+                self.assertEqual(url, tag.url)
diff --git a/pydis_site/apps/content/tests/test_views.py b/pydis_site/apps/content/tests/test_views.py
index c4d3474e..c5c25be4 100644
--- a/pydis_site/apps/content/tests/test_views.py
+++ b/pydis_site/apps/content/tests/test_views.py
@@ -194,6 +194,23 @@ class TagViewTests(django.test.TestCase):
         """Set test helpers, then set up fake filesystem."""
         super().setUp()
 
+    def test_routing(self):
+        """Test that the correct template is returned for each route."""
+        Tag.objects.create(name="example")
+        Tag.objects.create(name="grouped-tag", group="group-name")
+
+        cases = [
+            ("/pages/tags/example/", "content/tag.html"),
+            ("/pages/tags/group-name/", "content/listing.html"),
+            ("/pages/tags/group-name/grouped-tag/", "content/tag.html"),
+        ]
+
+        for url, template in cases:
+            with self.subTest(url=url):
+                response = self.client.get(url)
+                self.assertEqual(200, response.status_code)
+                self.assertTemplateUsed(response, template)
+
     def test_valid_tag_returns_200(self):
         """Test that a page is returned for a valid tag."""
         Tag.objects.create(name="example", body="This is the tag body.")
@@ -207,8 +224,8 @@ class TagViewTests(django.test.TestCase):
         response = self.client.get("/pages/tags/non-existent/")
         self.assertEqual(404, response.status_code)
 
-    def test_context(self):
-        """Check that the context contains all the necessary data."""
+    def test_context_tag(self):
+        """Test that the context contains the required data for a tag."""
         body = textwrap.dedent("""
         ---
         unused: frontmatter
@@ -222,12 +239,55 @@ class TagViewTests(django.test.TestCase):
             "page_title": "example",
             "page": markdown.markdown("Tag content here."),
             "tag": tag,
+            "breadcrumb_items": [
+                {"name": "Pages", "path": "."},
+                {"name": "Tags", "path": "tags"},
+            ]
         }
         for key in expected:
             self.assertEqual(
                 expected[key], response.context.get(key), f"context.{key} did not match"
             )
 
+    def test_context_grouped_tag(self):
+        """
+        Test the context for a tag in a group.
+
+        The only difference between this and a regular tag are the breadcrumbs,
+        so only those are checked.
+        """
+        Tag.objects.create(name="example", body="Body text", group="group-name")
+        response = self.client.get("/pages/tags/group-name/example/")
+        self.assertListEqual([
+            {"name": "Pages", "path": "."},
+            {"name": "Tags", "path": "tags"},
+            {"name": "group-name", "path": "tags/group-name"},
+        ], response.context.get("breadcrumb_items"))
+
+    def test_group_page(self):
+        """Test rendering of a group's root page."""
+        Tag.objects.create(name="tag-1", body="Body 1", group="group-name")
+        Tag.objects.create(name="tag-2", body="Body 2", group="group-name")
+        Tag.objects.create(name="not-included")
+
+        response = self.client.get("/pages/tags/group-name/")
+        content = response.content.decode("utf-8")
+
+        self.assertInHTML("<div class='level-left'>group-name</div>", content)
+        self.assertInHTML(
+            f"<a class='level-item fab fa-github' href='{Tag.URL_BASE}/group-name'>",
+            content
+        )
+        self.assertIn(">tag-1</span>", content)
+        self.assertIn(">tag-2</span>", content)
+        self.assertNotIn(
+            ">not-included</span>",
+            content,
+            "Tags not in this group shouldn't be rendered."
+        )
+
+        self.assertInHTML("<p>Body 1</p>", content)
+
     def test_markdown(self):
         """Test that markdown content is rendered properly."""
         body = textwrap.dedent("""
@@ -287,7 +347,7 @@ class TagViewTests(django.test.TestCase):
         body = filler_before + "`!tags return`" + filler_after
         Tag.objects.create(name="example", body=body)
 
-        other_url = reverse("content:tag", kwargs={"name": "return"})
+        other_url = reverse("content:tag", kwargs={"location": "return"})
         response = self.client.get("/pages/tags/example/")
         self.assertEqual(
             markdown.markdown(filler_before + f"[`!tags return`]({other_url})" + filler_after),
@@ -304,7 +364,7 @@ class TagViewTests(django.test.TestCase):
         content = response.content.decode("utf-8")
 
         self.assertTemplateUsed(response, "content/listing.html")
-        self.assertInHTML('<h1 class="title">Tags</h1>', content)
+        self.assertInHTML('<div class="level-left">Tags</div>', content)
 
         for tag_number in range(1, 4):
             self.assertIn(f"tag-{tag_number}</span>", content)
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index da6a024d..11100ba5 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -48,7 +48,7 @@ def get_tags_static() -> list[Tag]:
     This will return a cached value, so it should only be used for static builds.
     """
     tags = fetch_tags()
-    for tag in tags[3:5]:
+    for tag in tags[3:5]:  # pragma: no cover
         tag.group = "very-cool-group"
     return tags
 
@@ -190,6 +190,7 @@ def get_tag_category(
 
     # Flatten group description into a single string
     for group in groups.values():
+        # If the following string is updated, make sure to update it in the frontend JS as well
         group["description"] = "Contains the following tags: " + ", ".join(group["description"])
         data.append(group)