From 16ffd8e75ae0637489ad15138c74641b0317f4a7 Mon Sep 17 00:00:00 2001
From: Jordan Robinson <hello@jordanrobinson.org>
Date: Wed, 17 Sep 2025 21:33:06 +0100
Subject: [PATCH] add atom feed

---
 main/denylist.py                       |   1 +
 main/feeds.py                          |  18 +++-
 main/templates/main/analytic_list.html |   1 +
 main/templates/main/blog_index.html    |   1 +
 main/tests/test_analytics.py           |  44 ++++++---
 main/tests/test_feeds.py               | 121 ++++++++++++-------------
 main/urls.py                           |   5 +-
 7 files changed, 112 insertions(+), 79 deletions(-)

diff --git a/main/denylist.py b/main/denylist.py
index ba7ab397d58cd671f0540e7b30e1cfcfe2d1ebb2..b83a6b65bb10ee01a59ab728c84bafb9c8b77c7c 100644
--- a/main/denylist.py
+++ b/main/denylist.py
@@ -8,6 +8,7 @@ DISALLOWED_USERNAMES = [
     "administration",
     "administrator",
     "api",
+    "atom",
     "auth",
     "authentication",
     "billing",
diff --git a/main/feeds.py b/main/feeds.py
index e7085105e4445e81bc029781bc01aee17063bb61..cb2d3a95a8b49c932dad4e042f7f048004f0618a 100644
--- a/main/feeds.py
+++ b/main/feeds.py
@@ -7,7 +7,7 @@ from django.utils import timezone
 
 from main import models
 from main.util import reading_time
-from django.utils.feedgenerator import Rss201rev2Feed
+from django.utils.feedgenerator import Rss201rev2Feed, Atom1Feed
 
 class RSLRSSFeed(Rss201rev2Feed):
     def root_attributes(self):
@@ -60,7 +60,6 @@ class RSLRSSFeed(Rss201rev2Feed):
             handler.endElement("rsl:license")
             handler.endElement("rsl:content")
 
-
 class RSSBlogFeed(Feed):
     feed_type = RSLRSSFeed
     title = ""
@@ -120,6 +119,21 @@ class RSSBlogFeed(Feed):
             return {"rsl_content": rsl_content}
         return {}
 
+
+class AtomBlogFeed(RSSBlogFeed):
+    feed_type = Atom1Feed
+    subtitle = RSSBlogFeed.description
+
+    def __call__(self, request, *args, **kwargs):
+        if not hasattr(request, "subdomain"):
+            raise Http404()
+
+        user = models.User.objects.get(username=request.subdomain)
+
+        models.AnalyticPage.objects.create(user=user, path="atom")
+
+        return super().__call__(request, *args, **kwargs)
+
 # Helper to parse RSL XML
 
 RSL_NS = {"rsl": "https://rslstandard.org/rsl"}
diff --git a/main/templates/main/analytic_list.html b/main/templates/main/analytic_list.html
index 3fd7a7d76cbb739701d4cef92fa2612a7fd68bfe..7004d6e3769d829ded9dffc9850877568624fab4 100644
--- a/main/templates/main/analytic_list.html
+++ b/main/templates/main/analytic_list.html
@@ -11,6 +11,7 @@
     <ul>
         <li><a href="{% url 'analytic_page_detail' 'index' %}">index</a></li>
         <li><a href="{% url 'analytic_page_detail' 'rss' %}">rss</a></li>
+        <li><a href="{% url 'analytic_page_detail' 'atom' %}">atom</a></li>
         {% for page in page_list %}
         <li><a href="{% url 'analytic_page_detail' page.slug %}">{{ page.slug }}</a></li>
         {% endfor %}
diff --git a/main/templates/main/blog_index.html b/main/templates/main/blog_index.html
index 84be26e8ab439d15274768eae05f1c194ab494cd..06d8f010f3a606ff9e6d6e1d4f1076124f25e87a 100644
--- a/main/templates/main/blog_index.html
+++ b/main/templates/main/blog_index.html
@@ -6,6 +6,7 @@
 
 {% block head_extra %}
 <link rel="alternate" type="application/rss+xml" title="RSS" href="{% url 'rss_feed' %}">
+<link rel="alternate" type="application/atom+xml" title="Atom" href="{% url 'atom_feed' %}">
 {% if blog_user.blog_byline %}
 <meta name="description" content="{{ blog_user.blog_byline_as_text }}">
 {% endif %}
diff --git a/main/tests/test_analytics.py b/main/tests/test_analytics.py
index 43cb78da7c8d5f55201e5e09edbd465c059b12ba..9e7283bbb1380be9eb5422ec2259e14982e1c536 100644
--- a/main/tests/test_analytics.py
+++ b/main/tests/test_analytics.py
@@ -120,20 +120,20 @@ class PageAnalyticIndexTestCase(TestCase):
         self.assertEqual(models.AnalyticPage.objects.filter(path="index").count(), 1)
 
 
-class PageAnalyticRSSTestCase(TestCase):
+class PageAnalyticFeedTestCase(TestCase):
     """Test 'rss' special page analytics."""
 
     def setUp(self):
         self.user = models.User.objects.create(username="alice")
 
-    def test_rss_analytic(self):
-        response = self.client.get(
-            reverse("rss_feed"),
-            # needs HTTP_HOST because we need to request it on the subdomain
-            HTTP_HOST=self.user.username + "." + settings.CANONICAL_HOST,
-        )
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(models.AnalyticPage.objects.filter(path="rss").count(), 1)
+    def test_feed_analytic(self):
+        for feed in ["rss", "atom"]:
+            response = self.client.get(
+                reverse(f"{feed}_feed"),
+                HTTP_HOST=self.user.username + "." + settings.CANONICAL_HOST,
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(models.AnalyticPage.objects.filter(path=feed).count(), 1)
 
 
 class AnalyticListTestCase(TestCase):
@@ -264,26 +264,28 @@ class PageAnalyticDetailIndexTestCase(TestCase):
         self.assertContains(response, "1 hits")
 
 
-class PageAnalyticDetailRSSTestCase(TestCase):
+class PageAnalyticDetailFeedTestCase(TestCase):
     """Test analytic detail for 'rss' special page."""
 
-    def setUp(self):
+    def setup_feed_analytic_detail(self, feed):
         self.user = models.User.objects.create(username="alice")
         self.client.force_login(self.user)
 
         # logout so that analytic is counted
         self.client.logout()
 
-        # register one sample rss page analytic
+        # register one sample feed page analytic
         self.client.get(
-            reverse("rss_feed"),
+            reverse(feed),
             HTTP_HOST=self.user.username + "." + settings.CANONICAL_HOST,
         )
 
         # login again to access analytic page detail dashboard page
         self.client.force_login(self.user)
 
-    def test_page_analytic_detail(self):
+    def test_rss_page_analytic_detail(self):
+        self.setup_feed_analytic_detail("rss_feed")
+
         response = self.client.get(
             reverse("analytic_page_detail", args=("rss",)),
         )
@@ -294,3 +296,17 @@ class PageAnalyticDetailRSSTestCase(TestCase):
             '<svg version="1.1" viewBox="0 0 500 192" xmlns="http://www.w3.org/2000/svg">',
         )
         self.assertContains(response, "1 hits")
+
+    def test_atom_page_analytic_detail(self):
+        self.setup_feed_analytic_detail("atom_feed")
+
+        response = self.client.get(
+            reverse("analytic_page_detail", args=("atom",)),
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, '<div class="analytics-chart">')
+        self.assertContains(
+            response,
+            '<svg version="1.1" viewBox="0 0 500 192" xmlns="http://www.w3.org/2000/svg">',
+        )
+        self.assertContains(response, "1 hits")
\ No newline at end of file
diff --git a/main/tests/test_feeds.py b/main/tests/test_feeds.py
index 739024b9438aeb74a6dfabdb112820d8cf4e803f..cae327e9f169680669c0b2fec6fc3d3d6284ddf3 100644
--- a/main/tests/test_feeds.py
+++ b/main/tests/test_feeds.py
@@ -8,7 +8,7 @@ from main import models
 from mataroa import settings
 
 
-class RSSFeedTestCase(TestCase):
+class FeedTestCase(TestCase):
     def setUp(self):
         self.user = models.User.objects.create(username="alice")
         self.client.force_login(self.user)
@@ -21,22 +21,23 @@ class RSSFeedTestCase(TestCase):
         self.post = models.Post.objects.create(owner=self.user, **self.data)
 
     def test_rss_feed(self):
-        response = self.client.get(
-            reverse("rss_feed"),
-            HTTP_HOST=self.user.username + "." + settings.CANONICAL_HOST,
-        )
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response["Content-Type"], "application/rss+xml; charset=utf-8")
-        self.assertContains(response, self.data["title"])
-        self.assertContains(response, self.data["slug"])
-        self.assertContains(response, self.data["body"])
-        self.assertContains(
-            response,
-            f"//{self.user.username}.{settings.CANONICAL_HOST}/blog/{self.data['slug']}/</link>",
-        )
+        for feed in ["rss", "atom"]:
+            response = self.client.get(
+                reverse(f"{feed}_feed"),
+                HTTP_HOST=self.user.username + "." + settings.CANONICAL_HOST,
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response["Content-Type"], f"application/{feed}+xml; charset=utf-8")
+            self.assertContains(response, self.data["title"])
+            self.assertContains(response, self.data["slug"])
+            self.assertContains(response, self.data["body"])
+            self.assertContains(
+                response,
+                f"//{self.user.username}.{settings.CANONICAL_HOST}/blog/{self.data['slug']}/",
+            )
 
 
-class RSSFeedDraftsTestCase(TestCase):
+class FeedDraftsTestCase(TestCase):
     """Tests draft posts do not appear in the RSS feed."""
 
     def setUp(self):
@@ -58,25 +59,26 @@ class RSSFeedDraftsTestCase(TestCase):
         models.Post.objects.create(owner=self.user, **self.post_draft)
 
     def test_rss_feed(self):
-        response = self.client.get(
-            reverse("rss_feed"),
-            HTTP_HOST=self.user.username + "." + settings.CANONICAL_HOST,
-        )
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response["Content-Type"], "application/rss+xml; charset=utf-8")
-        self.assertContains(response, self.post_published["title"])
-        self.assertContains(response, self.post_published["slug"])
-        self.assertContains(response, self.post_published["body"])
-        self.assertNotContains(response, self.post_draft["title"])
-        self.assertNotContains(response, self.post_draft["slug"])
-        self.assertNotContains(response, self.post_draft["body"])
-        self.assertNotContains(
-            response,
-            f"//{self.user.username}.{settings.CANONICAL_HOST}/blog/{self.post_draft['slug']}/</link>",
-        )
+        for feed in ["rss", "atom"]:
+            response = self.client.get(
+                reverse(f"{feed}_feed"),
+                HTTP_HOST=self.user.username + "." + settings.CANONICAL_HOST,
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response["Content-Type"], f"application/{feed}+xml; charset=utf-8")
+            self.assertContains(response, self.post_published["title"])
+            self.assertContains(response, self.post_published["slug"])
+            self.assertContains(response, self.post_published["body"])
+            self.assertNotContains(response, self.post_draft["title"])
+            self.assertNotContains(response, self.post_draft["slug"])
+            self.assertNotContains(response, self.post_draft["body"])
+            self.assertNotContains(
+                response,
+                f"//{self.user.username}.{settings.CANONICAL_HOST}/blog/{self.post_draft['slug']}/</link>",
+            )
 
 
-class RSSFeedFuturePostTestCase(TestCase):
+class FeedFuturePostTestCase(TestCase):
     def setUp(self):
         self.user = models.User.objects.create(username="alice")
         self.client.force_login(self.user)
@@ -89,41 +91,36 @@ class RSSFeedFuturePostTestCase(TestCase):
         self.post = models.Post.objects.create(owner=self.user, **self.data)
 
     def test_future_post_hidden(self):
-        response = self.client.get(
-            reverse("rss_feed"),
-            # needs HTTP_HOST because we need to request it on the subdomain
-            HTTP_HOST=self.user.username + "." + settings.CANONICAL_HOST,
-        )
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response["Content-Type"], "application/rss+xml; charset=utf-8")
-        self.assertNotContains(response, self.data["title"])
-        self.assertNotContains(response, self.data["slug"])
-        self.assertNotContains(response, self.data["body"])
-        self.assertNotContains(
-            response,
-            f"//{self.user.username}.{settings.CANONICAL_HOST}/blog/{self.data['slug']}/</link>",
-        )
+        for feed in ["rss", "atom"]:
+            response = self.client.get(
+                reverse(f"{feed}_feed"),
+                # needs HTTP_HOST because we need to request it on the subdomain
+                HTTP_HOST=self.user.username + "." + settings.CANONICAL_HOST,
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response["Content-Type"], f"application/{feed}+xml; charset=utf-8")
+            self.assertNotContains(response, self.data["title"])
+            self.assertNotContains(response, self.data["slug"])
+            self.assertNotContains(response, self.data["body"])
+            self.assertNotContains(
+                response,
+                f"//{self.user.username}.{settings.CANONICAL_HOST}/blog/{self.data['slug']}/</link>",
+            )
 
 
-class RSSFeedFormatTestCase(TestCase):
+class FeedFormatTestCase(TestCase):
     def setUp(self):
         self.user = models.User.objects.create(
             username="alice", blog_title="test title", blog_byline="test about text"
         )
 
     def test_feed_valid(self):
-        response = self.client.get(
-            reverse("rss_feed"),
-            # needs HTTP_HOST because we need to request it on the subdomain
-            HTTP_HOST=self.user.username + "." + settings.CANONICAL_HOST,
-        )
-        self.assertEqual(response.status_code, 200)
-        self.assertContains(response, '<?xml version="1.0" encoding="utf-8"?>')
-        self.assertContains(
-            response,
-            '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">',
-        )
-        self.assertContains(response, f"<title>{self.user.blog_title}</title>")
-        self.assertContains(
-            response, f"<description>{self.user.blog_byline}</description>"
-        )
+        for feed in ["rss", "atom"]:
+            response = self.client.get(
+                reverse(f"{feed}_feed"),
+                # needs HTTP_HOST because we need to request it on the subdomain
+                HTTP_HOST=self.user.username + "." + settings.CANONICAL_HOST,
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertContains(response, '<?xml version="1.0" encoding="utf-8"?>')
+            self.assertContains(response, f"<title>{self.user.blog_title}</title>")
\ No newline at end of file
diff --git a/main/urls.py b/main/urls.py
index 33f0a1aca74e3b7aff04088bba999d237dadc079..02ae7ef2c10845ce229cf1e687e03c87a9275333 100644
--- a/main/urls.py
+++ b/main/urls.py
@@ -103,10 +103,13 @@ urlpatterns += [
 # blog extras
 urlpatterns += [
     path("rss/", feeds.RSSBlogFeed(), name="rss_feed"),
-    path("feed/", feeds.RSSBlogFeed(), name="rss_feed"),
+    path("atom/", feeds.AtomBlogFeed(), name="atom_feed"),
+    path("feed/", feeds.RSSBlogFeed()),
     path("feed/rss/", feeds.RSSBlogFeed()),
+    path("feed/atom/", feeds.AtomBlogFeed()),
     path("feed.xml", feeds.RSSBlogFeed()),
     path("rss.xml", feeds.RSSBlogFeed()),
+    path("atom.xml", feeds.AtomBlogFeed()),
     path("index.xml", feeds.RSSBlogFeed()),
 
     # really simple licensing