From a8fd8b823748ced96bb8ea34e8dcd8bd0dd57671 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Sat, 13 Aug 2022 08:47:29 +0200
Subject: Add Tag View Tests

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/tests/test_utils.py | 103 +++++++++++++++++++++-
 pydis_site/apps/content/tests/test_views.py | 128 ++++++++++++++++++++++++++++
 2 files changed, 230 insertions(+), 1 deletion(-)

(limited to 'pydis_site/apps/content/tests')

diff --git a/pydis_site/apps/content/tests/test_utils.py b/pydis_site/apps/content/tests/test_utils.py
index be5ea897..89ef81c4 100644
--- a/pydis_site/apps/content/tests/test_utils.py
+++ b/pydis_site/apps/content/tests/test_utils.py
@@ -1,8 +1,16 @@
+import tarfile
+import tempfile
+import textwrap
 from pathlib import Path
+from unittest import mock
 
+import httpx
+import markdown
 from django.http import Http404
+from django.test import TestCase
 
-from pydis_site.apps.content import utils
+from pydis_site import settings
+from pydis_site.apps.content import models, utils
 from pydis_site.apps.content.tests.helpers import (
     BASE_PATH, MockPagesTestCase, PARSED_CATEGORY_INFO, PARSED_HTML, PARSED_METADATA
 )
@@ -96,3 +104,96 @@ class GetPageTests(MockPagesTestCase):
     def test_get_nonexistent_page_returns_404(self):
         with self.assertRaises(Http404):
             utils.get_page(Path(BASE_PATH, "invalid"))
+
+
+class TagUtilsTests(TestCase):
+    """Tests for the tag-related utilities."""
+
+    @mock.patch.object(utils, "fetch_tags")
+    def test_static_fetch(self, fetch_mock: mock.Mock):
+        """Test that the static fetch function is only called at most once during static builds."""
+        tags = [models.Tag(name="Name", body="body", url="url")]
+        fetch_mock.return_value = tags
+        result = utils.get_tags_static()
+        second_result = utils.get_tags_static()
+
+        fetch_mock.assert_called_once()
+        self.assertEqual(tags, result)
+        self.assertEqual(tags, second_result)
+
+    @mock.patch("httpx.get")
+    def test_mocked_fetch(self, get_mock: mock.Mock):
+        """Test that proper data is returned from fetch, but with a mocked API response."""
+        bodies = (
+            "This is the first tag!",
+            textwrap.dedent("""
+                ---
+                frontmatter: empty
+                ---
+                This tag has frontmatter!
+            """),
+        )
+
+        # Generate a tar archive with a few tags
+        with tempfile.TemporaryDirectory() as tar_folder:
+            tar_folder = Path(tar_folder)
+            with tempfile.TemporaryDirectory() as folder:
+                folder = Path(folder)
+                (folder / "ignored_file.md").write_text("This is an ignored file.")
+                tags_folder = folder / "bot/resources/tags"
+                tags_folder.mkdir(parents=True)
+
+                (tags_folder / "first_tag.md").write_text(bodies[0])
+                (tags_folder / "second_tag.md").write_text(bodies[1])
+
+                with tarfile.open(tar_folder / "temp.tar", "w") as file:
+                    file.add(folder, recursive=True)
+
+                body = (tar_folder / "temp.tar").read_bytes()
+
+        get_mock.return_value = httpx.Response(
+            status_code=200,
+            content=body,
+            request=httpx.Request("GET", "https://google.com"),
+        )
+
+        result = utils.fetch_tags()
+        self.assertEqual([
+            models.Tag(name="first_tag", body=bodies[0], url=f"{utils.TAG_URL_BASE}/first_tag.md"),
+            models.Tag(name="second_tag", body=bodies[1], url=f"{utils.TAG_URL_BASE}/first_tag.md"),
+        ], sorted(result, key=lambda tag: tag.name))
+
+    def test_get_real_tag(self):
+        """Test that a single tag is returned if it exists."""
+        tag = models.Tag.objects.create(name="real-tag")
+        result = utils.get_tag("real-tag")
+
+        self.assertEqual(tag, 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"}
+
+        result = utils.get_category_pages(settings.CONTENT_PAGES_PATH / "tags")
+        self.assertDictEqual({
+            "first-tag": {**tag_body, "title": "first-tag"},
+            "second-tag": {**tag_body, "title": "second-tag"},
+        }, 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)
diff --git a/pydis_site/apps/content/tests/test_views.py b/pydis_site/apps/content/tests/test_views.py
index eadad7e3..a5867260 100644
--- a/pydis_site/apps/content/tests/test_views.py
+++ b/pydis_site/apps/content/tests/test_views.py
@@ -1,9 +1,14 @@
+import textwrap
 from pathlib import Path
 from unittest import TestCase
 
+import django.test
+import markdown
 from django.http import Http404
 from django.test import RequestFactory, SimpleTestCase, override_settings
+from django.urls import reverse
 
+from pydis_site.apps.content.models import Tag
 from pydis_site.apps.content.tests.helpers import (
     BASE_PATH, MockPagesTestCase, PARSED_CATEGORY_INFO, PARSED_HTML, PARSED_METADATA
 )
@@ -180,3 +185,126 @@ class PageOrCategoryViewTests(MockPagesTestCase, SimpleTestCase, TestCase):
                 {"name": PARSED_CATEGORY_INFO["title"], "path": Path("category/subcategory")},
             ]
         )
+
+
+class TagViewTests(django.test.TestCase):
+    """Tests for the TagView class."""
+
+    def setUp(self):
+        """Set test helpers, then set up fake filesystem."""
+        super().setUp()
+
+    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.", url="URL")
+        response = self.client.get("/pages/tags/example/")
+        self.assertEqual(200, response.status_code)
+        self.assertIn("This is the tag body", response.content.decode("utf-8"))
+        self.assertTemplateUsed(response, "content/tag.html")
+
+    def test_invalid_tag_404(self):
+        """Test that a tag which doesn't exist raises a 404."""
+        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."""
+        body = textwrap.dedent("""
+        ---
+        unused: frontmatter
+        ----
+        Tag content here.
+        """)
+
+        tag = Tag.objects.create(name="example", body=body, url="URL")
+        response = self.client.get("/pages/tags/example/")
+        expected = {
+            "page_title": "example",
+            "page": markdown.markdown("Tag content here."),
+            "tag": tag,
+        }
+        for key in expected:
+            self.assertEqual(
+                expected[key], response.context.get(key), f"context.{key} did not match"
+            )
+
+    def test_markdown(self):
+        """Test that markdown content is rendered properly."""
+        body = textwrap.dedent("""
+        ```py
+        Hello world!
+        ```
+
+        **This text is in bold**
+        """)
+
+        Tag.objects.create(name="example", body=body, url="URL")
+        response = self.client.get("/pages/tags/example/")
+        content = response.content.decode("utf-8")
+
+        self.assertInHTML('<code class="language-py">Hello world!</code>', content)
+        self.assertInHTML("<strong>This text is in bold</strong>", content)
+
+    def test_embed(self):
+        """Test that an embed from the frontmatter is treated correctly."""
+        body = textwrap.dedent("""
+        ---
+        embed:
+            title: Embed title
+            image:
+                url: https://google.com
+        ---
+        Tag body.
+        """)
+
+        Tag.objects.create(name="example", body=body, url="URL")
+        response = self.client.get("/pages/tags/example/")
+        content = response.content.decode("utf-8")
+
+        self.assertInHTML('<img alt="Embed title" src="https://google.com"/>', content)
+        self.assertInHTML("<p>Tag body.</p>", content)
+
+    def test_embed_title(self):
+        """Test that the page title gets set to the embed title."""
+        body = textwrap.dedent("""
+        ---
+        embed:
+            title: Embed title
+        ---
+        """)
+
+        Tag.objects.create(name="example", body=body, url="URL")
+        response = self.client.get("/pages/tags/example/")
+        self.assertEqual(
+            "Embed title",
+            response.context.get("page_title"),
+            "The page title must match the embed title."
+        )
+
+    def test_hyperlinked_item(self):
+        """Test hyperlinking of tags works as intended."""
+        filler_before, filler_after = "empty filler text\n\n", "more\nfiller"
+        body = filler_before + "`!tags return`" + filler_after
+        Tag.objects.create(name="example", body=body, url="URL")
+
+        other_url = reverse("content:tag", kwargs={"name": "return"})
+        response = self.client.get("/pages/tags/example/")
+        self.assertEqual(
+            markdown.markdown(filler_before + f"[`!tags return`]({other_url})" + filler_after),
+            response.context.get("page")
+        )
+
+    def test_tag_root_page(self):
+        """Test the root tag page which lists all tags."""
+        Tag.objects.create(name="tag-1")
+        Tag.objects.create(name="tag-2")
+        Tag.objects.create(name="tag-3")
+
+        response = self.client.get("/pages/tags/")
+        content = response.content.decode("utf-8")
+
+        self.assertTemplateUsed(response, "content/listing.html")
+        self.assertInHTML('<h1 class="title">Tags</h1>', content)
+
+        for tag_number in range(1, 4):
+            self.assertIn(f"tag-{tag_number}</span>", content)
-- 
cgit v1.2.3


From b4911d03faf8eecf5c4cced6f8036b0b2ef01d58 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Sun, 14 Aug 2022 04:44:57 +0200
Subject: Move Tag URL To Property And Add Group

The URLs can be simply constructed using the other tag properties, so
they were removed from the database in favor of a property.

A group field was also added to support tags within groups.

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 .../migrations/0002_remove_tag_url_tag_group.py    | 22 ++++++++++++++++++++++
 pydis_site/apps/content/models/tag.py              | 17 ++++++++++++++++-
 pydis_site/apps/content/tests/test_utils.py        |  6 +++---
 pydis_site/apps/content/tests/test_views.py        | 12 ++++++------
 4 files changed, 47 insertions(+), 10 deletions(-)
 create mode 100644 pydis_site/apps/content/migrations/0002_remove_tag_url_tag_group.py

(limited to 'pydis_site/apps/content/tests')

diff --git a/pydis_site/apps/content/migrations/0002_remove_tag_url_tag_group.py b/pydis_site/apps/content/migrations/0002_remove_tag_url_tag_group.py
new file mode 100644
index 00000000..e59077f0
--- /dev/null
+++ b/pydis_site/apps/content/migrations/0002_remove_tag_url_tag_group.py
@@ -0,0 +1,22 @@
+# Generated by Django 4.0.6 on 2022-08-13 23:48
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('content', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='tag',
+            name='url',
+        ),
+        migrations.AddField(
+            model_name='tag',
+            name='group',
+            field=models.CharField(help_text='The group the tag belongs to.', max_length=50, null=True),
+        ),
+    ]
diff --git a/pydis_site/apps/content/models/tag.py b/pydis_site/apps/content/models/tag.py
index 1437b96a..01264ff1 100644
--- a/pydis_site/apps/content/models/tag.py
+++ b/pydis_site/apps/content/models/tag.py
@@ -4,6 +4,8 @@ from django.db import models
 class Tag(models.Model):
     """A tag from the python-discord server."""
 
+    URL_BASE = "https://github.com/python-discord/bot/tree/main/bot/resources/tags"
+
     last_updated = models.DateTimeField(
         help_text="The date and time this data was last fetched.",
         auto_now=True,
@@ -13,5 +15,18 @@ class Tag(models.Model):
         primary_key=True,
         max_length=50,
     )
+    group = models.CharField(
+        help_text="The group the tag belongs to.",
+        null=True,
+        max_length=50,
+    )
     body = models.TextField(help_text="The content of the tag.")
-    url = models.URLField(help_text="The URL to this tag on GitHub.")
+
+    @property
+    def url(self) -> str:
+        """Get the URL of the tag on GitHub."""
+        url = Tag.URL_BASE
+        if self.group:
+            url += f"/{self.group}"
+        url += f"/{self.name}.md"
+        return url
diff --git a/pydis_site/apps/content/tests/test_utils.py b/pydis_site/apps/content/tests/test_utils.py
index 89ef81c4..a5d5dcb4 100644
--- a/pydis_site/apps/content/tests/test_utils.py
+++ b/pydis_site/apps/content/tests/test_utils.py
@@ -112,7 +112,7 @@ class TagUtilsTests(TestCase):
     @mock.patch.object(utils, "fetch_tags")
     def test_static_fetch(self, fetch_mock: mock.Mock):
         """Test that the static fetch function is only called at most once during static builds."""
-        tags = [models.Tag(name="Name", body="body", url="url")]
+        tags = [models.Tag(name="Name", body="body")]
         fetch_mock.return_value = tags
         result = utils.get_tags_static()
         second_result = utils.get_tags_static()
@@ -159,8 +159,8 @@ class TagUtilsTests(TestCase):
 
         result = utils.fetch_tags()
         self.assertEqual([
-            models.Tag(name="first_tag", body=bodies[0], url=f"{utils.TAG_URL_BASE}/first_tag.md"),
-            models.Tag(name="second_tag", body=bodies[1], url=f"{utils.TAG_URL_BASE}/first_tag.md"),
+            models.Tag(name="first_tag", body=bodies[0]),
+            models.Tag(name="second_tag", body=bodies[1]),
         ], sorted(result, key=lambda tag: tag.name))
 
     def test_get_real_tag(self):
diff --git a/pydis_site/apps/content/tests/test_views.py b/pydis_site/apps/content/tests/test_views.py
index a5867260..c4d3474e 100644
--- a/pydis_site/apps/content/tests/test_views.py
+++ b/pydis_site/apps/content/tests/test_views.py
@@ -196,7 +196,7 @@ class TagViewTests(django.test.TestCase):
 
     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.", url="URL")
+        Tag.objects.create(name="example", body="This is the tag body.")
         response = self.client.get("/pages/tags/example/")
         self.assertEqual(200, response.status_code)
         self.assertIn("This is the tag body", response.content.decode("utf-8"))
@@ -216,7 +216,7 @@ class TagViewTests(django.test.TestCase):
         Tag content here.
         """)
 
-        tag = Tag.objects.create(name="example", body=body, url="URL")
+        tag = Tag.objects.create(name="example", body=body)
         response = self.client.get("/pages/tags/example/")
         expected = {
             "page_title": "example",
@@ -238,7 +238,7 @@ class TagViewTests(django.test.TestCase):
         **This text is in bold**
         """)
 
-        Tag.objects.create(name="example", body=body, url="URL")
+        Tag.objects.create(name="example", body=body)
         response = self.client.get("/pages/tags/example/")
         content = response.content.decode("utf-8")
 
@@ -257,7 +257,7 @@ class TagViewTests(django.test.TestCase):
         Tag body.
         """)
 
-        Tag.objects.create(name="example", body=body, url="URL")
+        Tag.objects.create(name="example", body=body)
         response = self.client.get("/pages/tags/example/")
         content = response.content.decode("utf-8")
 
@@ -273,7 +273,7 @@ class TagViewTests(django.test.TestCase):
         ---
         """)
 
-        Tag.objects.create(name="example", body=body, url="URL")
+        Tag.objects.create(name="example", body=body)
         response = self.client.get("/pages/tags/example/")
         self.assertEqual(
             "Embed title",
@@ -285,7 +285,7 @@ class TagViewTests(django.test.TestCase):
         """Test hyperlinking of tags works as intended."""
         filler_before, filler_after = "empty filler text\n\n", "more\nfiller"
         body = filler_before + "`!tags return`" + filler_after
-        Tag.objects.create(name="example", body=body, url="URL")
+        Tag.objects.create(name="example", body=body)
 
         other_url = reverse("content:tag", kwargs={"name": "return"})
         response = self.client.get("/pages/tags/example/")
-- 
cgit v1.2.3


From 5aeffa5ab4dd8b251d2ae742d1a1e2bf3ba461c7 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Sun, 14 Aug 2022 07:14:50 +0200
Subject: Update Tests For Tag Groups

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/tests/test_utils.py | 110 +++++++++++++++++++++++-----
 pydis_site/apps/content/tests/test_views.py |  68 ++++++++++++++++-
 pydis_site/apps/content/utils.py            |   3 +-
 3 files changed, 157 insertions(+), 24 deletions(-)

(limited to 'pydis_site/apps/content/tests')

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)
 
-- 
cgit v1.2.3


From 92a42694b6ad1a29e5a21e0b3e57639528837113 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Tue, 16 Aug 2022 23:45:25 +0400
Subject: Fix Tests For Tag Metadata

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/api/tests/test_github_utils.py |   7 +-
 pydis_site/apps/content/tests/test_utils.py    | 132 +++++++++++++++++++++++--
 pydis_site/apps/content/tests/test_views.py    |  36 ++++---
 pydis_site/apps/content/utils.py               |   2 +-
 4 files changed, 148 insertions(+), 29 deletions(-)

(limited to 'pydis_site/apps/content/tests')

diff --git a/pydis_site/apps/api/tests/test_github_utils.py b/pydis_site/apps/api/tests/test_github_utils.py
index f642f689..6e25bc80 100644
--- a/pydis_site/apps/api/tests/test_github_utils.py
+++ b/pydis_site/apps/api/tests/test_github_utils.py
@@ -11,6 +11,7 @@ import rest_framework.response
 import rest_framework.test
 from django.urls import reverse
 
+from pydis_site import settings
 from .. import github_utils
 
 
@@ -49,7 +50,7 @@ class CheckRunTests(unittest.TestCase):
         "head_sha": "sha",
         "status": "completed",
         "conclusion": "success",
-        "created_at": datetime.datetime.utcnow().strftime(github_utils.ISO_FORMAT_STRING),
+        "created_at": datetime.datetime.utcnow().strftime(settings.GITHUB_TIMESTAMP_FORMAT),
         "artifacts_url": "url",
     }
 
@@ -74,7 +75,7 @@ class CheckRunTests(unittest.TestCase):
         # to guarantee the right conclusion
         kwargs["created_at"] = (
             datetime.datetime.utcnow() - github_utils.MAX_RUN_TIME - datetime.timedelta(minutes=10)
-        ).strftime(github_utils.ISO_FORMAT_STRING)
+        ).strftime(settings.GITHUB_TIMESTAMP_FORMAT)
 
         with self.assertRaises(github_utils.RunTimeoutError):
             github_utils.check_run_status(github_utils.WorkflowRun(**kwargs))
@@ -178,7 +179,7 @@ class ArtifactFetcherTests(unittest.TestCase):
                 run = github_utils.WorkflowRun(
                     name="action_name",
                     head_sha="action_sha",
-                    created_at=datetime.datetime.now().strftime(github_utils.ISO_FORMAT_STRING),
+                    created_at=datetime.datetime.now().strftime(settings.GITHUB_TIMESTAMP_FORMAT),
                     status="completed",
                     conclusion="success",
                     artifacts_url="artifacts_url"
diff --git a/pydis_site/apps/content/tests/test_utils.py b/pydis_site/apps/content/tests/test_utils.py
index 556f633c..2ef033e4 100644
--- a/pydis_site/apps/content/tests/test_utils.py
+++ b/pydis_site/apps/content/tests/test_utils.py
@@ -1,3 +1,5 @@
+import datetime
+import json
 import tarfile
 import tempfile
 import textwrap
@@ -15,6 +17,18 @@ from pydis_site.apps.content.tests.helpers import (
     BASE_PATH, MockPagesTestCase, PARSED_CATEGORY_INFO, PARSED_HTML, PARSED_METADATA
 )
 
+_time = datetime.datetime(2022, 10, 10, 10, 10, 10, tzinfo=datetime.timezone.utc)
+_time_str = _time.strftime(settings.GITHUB_TIMESTAMP_FORMAT)
+TEST_COMMIT_KWARGS = {
+    "sha": "123",
+    "message": "Hello world\n\nThis is a commit message",
+    "date": _time,
+    "author": json.dumps([
+        {"name": "Author 1", "email": "mail1@example.com", "date": _time_str},
+        {"name": "Author 2", "email": "mail2@example.com", "date": _time_str},
+    ]),
+}
+
 
 class GetCategoryTests(MockPagesTestCase):
     """Tests for the get_category function."""
@@ -109,6 +123,10 @@ class GetPageTests(MockPagesTestCase):
 class TagUtilsTests(TestCase):
     """Tests for the tag-related utilities."""
 
+    def setUp(self) -> None:
+        super().setUp()
+        self.commit = models.Commit.objects.create(**TEST_COMMIT_KWARGS)
+
     @mock.patch.object(utils, "fetch_tags")
     def test_static_fetch(self, fetch_mock: mock.Mock):
         """Test that the static fetch function is only called at most once during static builds."""
@@ -121,9 +139,27 @@ class TagUtilsTests(TestCase):
         self.assertEqual(tags, result)
         self.assertEqual(tags, second_result)
 
-    @mock.patch("httpx.get")
+    @mock.patch("httpx.Client.get")
     def test_mocked_fetch(self, get_mock: mock.Mock):
         """Test that proper data is returned from fetch, but with a mocked API response."""
+        fake_request = httpx.Request("GET", "https://google.com")
+
+        # Metadata requests
+        returns = [httpx.Response(
+            request=fake_request,
+            status_code=200,
+            json=[
+                {"type": "file", "name": "first_tag.md", "sha": "123"},
+                {"type": "file", "name": "second_tag.md", "sha": "456"},
+                {"type": "dir", "name": "some_group", "sha": "789", "url": "/some_group"},
+            ]
+        ), httpx.Response(
+            request=fake_request,
+            status_code=200,
+            json=[{"type": "file", "name": "grouped_tag.md", "sha": "789123"}]
+        )]
+
+        # Main content request
         bodies = (
             "This is the first tag!",
             textwrap.dedent("""
@@ -156,33 +192,36 @@ class TagUtilsTests(TestCase):
 
                 body = (tar_folder / "temp.tar").read_bytes()
 
-        get_mock.return_value = httpx.Response(
+        returns.append(httpx.Response(
             status_code=200,
             content=body,
-            request=httpx.Request("GET", "https://google.com"),
-        )
+            request=fake_request,
+        ))
 
+        get_mock.side_effect = returns
         result = utils.fetch_tags()
 
         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]),
-            models.Tag(name="grouped_tag", body=bodies[2], group=group_folder.name),
+            models.Tag(name="first_tag", body=bodies[0], sha="123"),
+            models.Tag(name="second_tag", body=bodies[1], sha="245"),
+            models.Tag(name="grouped_tag", body=bodies[2], group=group_folder.name, sha="789123"),
         ], key=sort), sorted(result, key=sort))
 
     def test_get_real_tag(self):
         """Test that a single tag is returned if it exists."""
-        tag = models.Tag.objects.create(name="real-tag")
+        tag = models.Tag.objects.create(name="real-tag", last_commit=self.commit)
         result = utils.get_tag("real-tag")
 
         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")
+        tag = models.Tag.objects.create(
+            name="real-tag", group="real-group", last_commit=self.commit
+        )
         result = utils.get_tag("real-group/real-tag")
 
         self.assertEqual(tag, result)
@@ -269,3 +308,78 @@ class TagUtilsTests(TestCase):
             tag = models.Tag(**options)
             with self.subTest(tag=tag):
                 self.assertEqual(url, tag.url)
+
+    @mock.patch("httpx.Client.get")
+    def test_get_tag_commit(self, get_mock: mock.Mock):
+        """Test the get commit function with a normal tag."""
+        tag = models.Tag.objects.create(name="example")
+
+        authors = json.loads(self.commit.author)
+
+        get_mock.return_value = httpx.Response(
+            request=httpx.Request("GET", "https://google.com"),
+            status_code=200,
+            json=[{
+                "sha": self.commit.sha,
+                "commit": {
+                    "message": self.commit.message,
+                    "author": authors[0],
+                    "committer": authors[1],
+                }
+            }]
+        )
+
+        result = utils.get_tag(tag.name)
+        self.assertEqual(tag, result)
+
+        get_mock.assert_called_once()
+        call_params = get_mock.call_args[1]["params"]
+
+        self.assertEqual({"path": "/bot/resources/tags/example.md"}, call_params)
+        self.assertEqual(self.commit, models.Tag.objects.get(name=tag.name).last_commit)
+
+    @mock.patch("httpx.Client.get")
+    def test_get_group_tag_commit(self, get_mock: mock.Mock):
+        """Test the get commit function with a group tag."""
+        tag = models.Tag.objects.create(name="example", group="group-name")
+
+        authors = json.loads(self.commit.author)
+        authors.pop()
+        self.commit.author = json.dumps(authors)
+        self.commit.save()
+
+        get_mock.return_value = httpx.Response(
+            request=httpx.Request("GET", "https://google.com"),
+            status_code=200,
+            json=[{
+                "sha": self.commit.sha,
+                "commit": {
+                    "message": self.commit.message,
+                    "author": authors[0],
+                    "committer": authors[0],
+                }
+            }]
+        )
+
+        utils.set_tag_commit(tag)
+
+        get_mock.assert_called_once()
+        call_params = get_mock.call_args[1]["params"]
+
+        self.assertEqual({"path": "/bot/resources/tags/group-name/example.md"}, call_params)
+        self.assertEqual(self.commit, models.Tag.objects.get(name=tag.name).last_commit)
+
+    @mock.patch.object(utils, "set_tag_commit")
+    def test_exiting_commit(self, set_commit_mock: mock.Mock):
+        """Test that a commit is saved when the data has not changed."""
+        tag = models.Tag.objects.create(name="tag-name", body="old body", last_commit=self.commit)
+
+        # This is only applied to the object, not to the database
+        tag.last_commit = None
+
+        utils.record_tags([tag])
+        self.assertEqual(self.commit, tag.last_commit)
+
+        result = utils.get_tag("tag-name")
+        self.assertEqual(tag, result)
+        set_commit_mock.assert_not_called()
diff --git a/pydis_site/apps/content/tests/test_views.py b/pydis_site/apps/content/tests/test_views.py
index c5c25be4..658ac2cc 100644
--- a/pydis_site/apps/content/tests/test_views.py
+++ b/pydis_site/apps/content/tests/test_views.py
@@ -8,10 +8,11 @@ from django.http import Http404
 from django.test import RequestFactory, SimpleTestCase, override_settings
 from django.urls import reverse
 
-from pydis_site.apps.content.models import Tag
+from pydis_site.apps.content.models import Commit, Tag
 from pydis_site.apps.content.tests.helpers import (
     BASE_PATH, MockPagesTestCase, PARSED_CATEGORY_INFO, PARSED_HTML, PARSED_METADATA
 )
+from pydis_site.apps.content.tests.test_utils import TEST_COMMIT_KWARGS
 from pydis_site.apps.content.views import PageOrCategoryView
 
 
@@ -193,11 +194,12 @@ class TagViewTests(django.test.TestCase):
     def setUp(self):
         """Set test helpers, then set up fake filesystem."""
         super().setUp()
+        self.commit = Commit.objects.create(**TEST_COMMIT_KWARGS)
 
     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")
+        Tag.objects.create(name="example", last_commit=self.commit)
+        Tag.objects.create(name="grouped-tag", group="group-name", last_commit=self.commit)
 
         cases = [
             ("/pages/tags/example/", "content/tag.html"),
@@ -213,7 +215,7 @@ class TagViewTests(django.test.TestCase):
 
     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.")
+        Tag.objects.create(name="example", body="This is the tag body.", last_commit=self.commit)
         response = self.client.get("/pages/tags/example/")
         self.assertEqual(200, response.status_code)
         self.assertIn("This is the tag body", response.content.decode("utf-8"))
@@ -233,7 +235,7 @@ class TagViewTests(django.test.TestCase):
         Tag content here.
         """)
 
-        tag = Tag.objects.create(name="example", body=body)
+        tag = Tag.objects.create(name="example", body=body, last_commit=self.commit)
         response = self.client.get("/pages/tags/example/")
         expected = {
             "page_title": "example",
@@ -256,7 +258,9 @@ class TagViewTests(django.test.TestCase):
         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")
+        Tag.objects.create(
+            name="example", body="Body text", group="group-name", last_commit=self.commit
+        )
         response = self.client.get("/pages/tags/group-name/example/")
         self.assertListEqual([
             {"name": "Pages", "path": "."},
@@ -266,9 +270,9 @@ class TagViewTests(django.test.TestCase):
 
     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")
+        Tag.objects.create(name="tag-1", body="Body 1", group="group-name", last_commit=self.commit)
+        Tag.objects.create(name="tag-2", body="Body 2", group="group-name", last_commit=self.commit)
+        Tag.objects.create(name="not-included", last_commit=self.commit)
 
         response = self.client.get("/pages/tags/group-name/")
         content = response.content.decode("utf-8")
@@ -298,7 +302,7 @@ class TagViewTests(django.test.TestCase):
         **This text is in bold**
         """)
 
-        Tag.objects.create(name="example", body=body)
+        Tag.objects.create(name="example", body=body, last_commit=self.commit)
         response = self.client.get("/pages/tags/example/")
         content = response.content.decode("utf-8")
 
@@ -317,7 +321,7 @@ class TagViewTests(django.test.TestCase):
         Tag body.
         """)
 
-        Tag.objects.create(name="example", body=body)
+        Tag.objects.create(name="example", body=body, last_commit=self.commit)
         response = self.client.get("/pages/tags/example/")
         content = response.content.decode("utf-8")
 
@@ -333,7 +337,7 @@ class TagViewTests(django.test.TestCase):
         ---
         """)
 
-        Tag.objects.create(name="example", body=body)
+        Tag.objects.create(name="example", body=body, last_commit=self.commit)
         response = self.client.get("/pages/tags/example/")
         self.assertEqual(
             "Embed title",
@@ -345,7 +349,7 @@ class TagViewTests(django.test.TestCase):
         """Test hyperlinking of tags works as intended."""
         filler_before, filler_after = "empty filler text\n\n", "more\nfiller"
         body = filler_before + "`!tags return`" + filler_after
-        Tag.objects.create(name="example", body=body)
+        Tag.objects.create(name="example", body=body, last_commit=self.commit)
 
         other_url = reverse("content:tag", kwargs={"location": "return"})
         response = self.client.get("/pages/tags/example/")
@@ -356,9 +360,9 @@ class TagViewTests(django.test.TestCase):
 
     def test_tag_root_page(self):
         """Test the root tag page which lists all tags."""
-        Tag.objects.create(name="tag-1")
-        Tag.objects.create(name="tag-2")
-        Tag.objects.create(name="tag-3")
+        Tag.objects.create(name="tag-1", last_commit=self.commit)
+        Tag.objects.create(name="tag-2", last_commit=self.commit)
+        Tag.objects.create(name="tag-3", last_commit=self.commit)
 
         response = self.client.get("/pages/tags/")
         content = response.content.decode("utf-8")
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index e4a24a73..63f1c41c 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -130,7 +130,7 @@ def fetch_tags() -> list[Tag]:
 
 def set_tag_commit(tag: Tag) -> None:
     """Fetch commit information from the API, and save it for the tag."""
-    if settings.STATIC_BUILD:
+    if settings.STATIC_BUILD:  # pragma: no cover
         # Static builds request every page during build, which can ratelimit it.
         # Instead, we return some fake data.
         tag.last_commit = Commit(
-- 
cgit v1.2.3


From efe784fe8a6c23248c6698aefab8bf54c5c85900 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Tue, 23 Aug 2022 12:54:16 +0400
Subject: Support Hyperlinked Tag Group Replacement

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/tests/test_views.py | 28 ++++++++++++++++++++++++++++
 pydis_site/apps/content/utils.py            |  4 ++--
 pydis_site/apps/content/views/tags.py       | 26 +++++++++++++++++++++++---
 3 files changed, 53 insertions(+), 5 deletions(-)

(limited to 'pydis_site/apps/content/tests')

diff --git a/pydis_site/apps/content/tests/test_views.py b/pydis_site/apps/content/tests/test_views.py
index 658ac2cc..da06fc80 100644
--- a/pydis_site/apps/content/tests/test_views.py
+++ b/pydis_site/apps/content/tests/test_views.py
@@ -358,6 +358,34 @@ class TagViewTests(django.test.TestCase):
             response.context.get("page")
         )
 
+    def test_hyperlinked_group(self):
+        """Test hyperlinking with a group works as intended."""
+        Tag.objects.create(
+            name="example", body="!tags group-name grouped-tag", last_commit=self.commit
+        )
+        Tag.objects.create(name="grouped-tag", group="group-name")
+
+        other_url = reverse("content:tag", kwargs={"location": "group-name/grouped-tag"})
+        response = self.client.get("/pages/tags/example/")
+        self.assertEqual(
+            markdown.markdown(f"[!tags group-name grouped-tag]({other_url})"),
+            response.context.get("page")
+        )
+
+    def test_hyperlinked_extra_text(self):
+        """Test hyperlinking when a tag is followed by extra, unrelated text."""
+        Tag.objects.create(
+            name="example", body="!tags other unrelated text", last_commit=self.commit
+        )
+        Tag.objects.create(name="other")
+
+        other_url = reverse("content:tag", kwargs={"location": "other"})
+        response = self.client.get("/pages/tags/example/")
+        self.assertEqual(
+            markdown.markdown(f"[!tags other]({other_url}) unrelated text"),
+            response.context.get("page")
+        )
+
     def test_tag_root_page(self):
         """Test the root tag page which lists all tags."""
         Tag.objects.create(name="tag-1", last_commit=self.commit)
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index 63f1c41c..32d3d638 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -221,7 +221,7 @@ def get_tags() -> list[Tag]:
         return Tag.objects.all()
 
 
-def get_tag(path: str) -> typing.Union[Tag, list[Tag]]:
+def get_tag(path: str, *, skip_sync: bool = False) -> typing.Union[Tag, list[Tag]]:
     """
     Return a tag based on the search location.
 
@@ -243,7 +243,7 @@ def get_tag(path: str) -> typing.Union[Tag, list[Tag]]:
     matches = []
     for tag in get_tags():
         if tag.name == name and tag.group == group:
-            if tag.last_commit is None:
+            if tag.last_commit is None and not skip_sync:
                 set_tag_commit(tag)
             return tag
         elif tag.group == name and group is None:
diff --git a/pydis_site/apps/content/views/tags.py b/pydis_site/apps/content/views/tags.py
index a8df65db..4f4bb5a2 100644
--- a/pydis_site/apps/content/views/tags.py
+++ b/pydis_site/apps/content/views/tags.py
@@ -11,7 +11,12 @@ from django.views.generic import TemplateView
 from pydis_site.apps.content import utils
 from pydis_site.apps.content.models import Tag
 
-COMMAND_REGEX = re.compile(r"`*!tags? (?P<name>[\w\d-]+)`*")
+# The following regex tries to parse a tag command
+# It'll read up to two words seperated by spaces
+# If the command does not include a group, the tag name will be in the `first` group
+# If there's a second word after the command, or if there's a tag group, extra logic
+# is necessary to determine whether it's a tag with a group, or a tag with text after it
+COMMAND_REGEX = re.compile(r"`*!tags? (?P<first>[\w-]+)(?P<second> [\w-]+)?`*")
 
 
 class TagView(TemplateView):
@@ -75,8 +80,23 @@ class TagView(TemplateView):
 
         # Check for tags which can be hyperlinked
         def sub(match: re.Match) -> str:
-            link = reverse("content:tag", kwargs={"location": match.group("name")})
-            return f"[{match.group()}]({link})"
+            first, second = match.groups()
+            location = first
+            text, extra = match.group(), ""
+
+            if second is not None:
+                # Possibly a tag group
+                try:
+                    new_location = f"{first}/{second.strip()}"
+                    utils.get_tag(new_location, skip_sync=True)
+                    location = new_location
+                except Tag.DoesNotExist:
+                    # Not a group, remove the second argument from the link
+                    extra = text[text.find(second):]
+                    text = text[:text.find(second)]
+
+            link = reverse("content:tag", kwargs={"location": location})
+            return f"[{text}]({link}){extra}"
         content = COMMAND_REGEX.sub(sub, content)
 
         # Add support for some embed elements
-- 
cgit v1.2.3


From 2343f7ab5c738b5b28554c766e78eb6a663bd064 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Tue, 23 Aug 2022 13:11:35 +0400
Subject: Rename Tag Model Author Field

Renames the tag model `author` field to `authors` to better indicate
what's contained in the field, and updates the documentation.

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/migrations/0001_add_tags.py | 4 ++--
 pydis_site/apps/content/models/tag.py               | 9 +++++++--
 pydis_site/apps/content/tests/test_utils.py         | 8 ++++----
 pydis_site/apps/content/utils.py                    | 8 ++++----
 4 files changed, 17 insertions(+), 12 deletions(-)

(limited to 'pydis_site/apps/content/tests')

diff --git a/pydis_site/apps/content/migrations/0001_add_tags.py b/pydis_site/apps/content/migrations/0001_add_tags.py
index 73525243..2c31e4c1 100644
--- a/pydis_site/apps/content/migrations/0001_add_tags.py
+++ b/pydis_site/apps/content/migrations/0001_add_tags.py
@@ -1,4 +1,4 @@
-# Generated by Django 4.0.6 on 2022-08-16 17:38
+# Generated by Django 4.0.6 on 2022-08-23 09:06
 
 import django.db.models.deletion
 from django.db import migrations, models
@@ -18,7 +18,7 @@ class Migration(migrations.Migration):
                 ('sha', models.CharField(help_text='The SHA hash of this commit.', max_length=40, primary_key=True, serialize=False)),
                 ('message', models.TextField(help_text='The commit message.')),
                 ('date', models.DateTimeField(help_text='The date and time the commit was created.')),
-                ('author', models.TextField(help_text='The person(s) who created the commit.')),
+                ('authors', models.TextField(help_text='The person(s) who created the commit. This is a serialized JSON object. Refer to the GitHub documentation on the commit endpoint (schema/commit.author & schema/commit.committer) for more info. https://docs.github.com/en/rest/commits/commits#get-a-commit')),
             ],
         ),
         migrations.CreateModel(
diff --git a/pydis_site/apps/content/models/tag.py b/pydis_site/apps/content/models/tag.py
index e06ce067..1a20d775 100644
--- a/pydis_site/apps/content/models/tag.py
+++ b/pydis_site/apps/content/models/tag.py
@@ -16,7 +16,12 @@ class Commit(models.Model):
     )
     message = models.TextField(help_text="The commit message.")
     date = models.DateTimeField(help_text="The date and time the commit was created.")
-    author = models.TextField(help_text="The person(s) who created the commit.")
+    authors = models.TextField(help_text=(
+        "The person(s) who created the commit. This is a serialized JSON object. "
+        "Refer to the GitHub documentation on the commit endpoint "
+        "(schema/commit.author & schema/commit.committer) for more info. "
+        "https://docs.github.com/en/rest/commits/commits#get-a-commit"
+    ))
 
     @property
     def url(self) -> str:
@@ -30,7 +35,7 @@ class Commit(models.Model):
 
     def format_authors(self) -> collections.abc.Iterable[str]:
         """Return a nice representation of the author(s)' name and email."""
-        for author in json.loads(self.author):
+        for author in json.loads(self.authors):
             yield f"{author['name']} <{author['email']}>"
 
 
diff --git a/pydis_site/apps/content/tests/test_utils.py b/pydis_site/apps/content/tests/test_utils.py
index 2ef033e4..462818b5 100644
--- a/pydis_site/apps/content/tests/test_utils.py
+++ b/pydis_site/apps/content/tests/test_utils.py
@@ -23,7 +23,7 @@ TEST_COMMIT_KWARGS = {
     "sha": "123",
     "message": "Hello world\n\nThis is a commit message",
     "date": _time,
-    "author": json.dumps([
+    "authors": json.dumps([
         {"name": "Author 1", "email": "mail1@example.com", "date": _time_str},
         {"name": "Author 2", "email": "mail2@example.com", "date": _time_str},
     ]),
@@ -314,7 +314,7 @@ class TagUtilsTests(TestCase):
         """Test the get commit function with a normal tag."""
         tag = models.Tag.objects.create(name="example")
 
-        authors = json.loads(self.commit.author)
+        authors = json.loads(self.commit.authors)
 
         get_mock.return_value = httpx.Response(
             request=httpx.Request("GET", "https://google.com"),
@@ -343,9 +343,9 @@ class TagUtilsTests(TestCase):
         """Test the get commit function with a group tag."""
         tag = models.Tag.objects.create(name="example", group="group-name")
 
-        authors = json.loads(self.commit.author)
+        authors = json.loads(self.commit.authors)
         authors.pop()
-        self.commit.author = json.dumps(authors)
+        self.commit.authors = json.dumps(authors)
         self.commit.save()
 
         get_mock.return_value = httpx.Response(
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index 32d3d638..a1171a45 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -137,7 +137,7 @@ def set_tag_commit(tag: Tag) -> None:
             sha="68da80efc00d9932a209d5cccd8d344cec0f09ea",
             message="Initial Commit\n\nTHIS IS FAKE DEMO DATA",
             date=datetime.datetime(2018, 2, 3, 12, 20, 26, tzinfo=datetime.timezone.utc),
-            author=json.dumps([{"name": "Joseph", "email": "joseph@josephbanks.me"}]),
+            authors=json.dumps([{"name": "Joseph", "email": "joseph@josephbanks.me"}]),
         )
         return
 
@@ -159,15 +159,15 @@ def set_tag_commit(tag: Tag) -> None:
     date = date.replace(tzinfo=datetime.timezone.utc)
 
     if author["email"] == committer["email"]:
-        commit_author = [author]
+        authors = [author]
     else:
-        commit_author = [author, committer]
+        authors = [author, committer]
 
     commit_obj, _ = Commit.objects.get_or_create(
         sha=data["sha"],
         message=commit["message"],
         date=date,
-        author=json.dumps(commit_author),
+        authors=json.dumps(authors),
     )
     tag.last_commit = commit_obj
     tag.save()
-- 
cgit v1.2.3