feat: check if a lower-case version of a URL exists

Author: ianmeigh

tbx/core/tests/test_middleware.py

@@ -0,0 +1,67 @@
+from urllib.parse import urlsplit
+
+from wagtail.contrib.redirects.models import Redirect
+from wagtail.models import Site
+from wagtail.test.utils import WagtailPageTestCase
+
+from tbx.blog.factories import BlogIndexPageFactory
+from tbx.core.factories import HomePageFactory
+from tbx.divisions.factories import DivisionPageFactory
+
+
+class TestMiddleware(WagtailPageTestCase):
+    @classmethod
+    def setUpTestData(cls):
+        super().setUpTestData()
+
+        # Set up the site & homepage
+        site = Site.objects.get(is_default_site=True)
+        root = site.root_page.specific
+        cls.home = HomePageFactory(parent=root)
+
+        site.root_page = cls.home
+        site.save()
+
+        # Set up a division page
+        cls.division_page = DivisionPageFactory(
+            title="Charity",
+            parent=cls.home,
+        )
+
+        # Set up a blog page
+        cls.blog_page = BlogIndexPageFactory(
+            title="Blog",
+            parent=cls.division_page,
+        )
+
+    def test_page_accessible(self):
+        response = self.client.get(self.blog_page.url)
+        self.assertEqual(response.status_code, 200)
+
+    def test_redirects_to_lowercase_page(self):
+        response = self.client.get(self.blog_page.url.upper())
+        self.assertEqual(response.status_code, 301)
+        self.assertEqual(response.url, self.blog_page.url)
+
+    def test_maintains_querystring(self):
+        response = self.client.get(self.blog_page.url.upper(), {"foo": "BAR"})
+        split_result = urlsplit(response.url)
+        self.assertEqual(response.status_code, 301)
+        self.assertEqual(split_result.query, "foo=BAR")
+
+    def test_404(self):
+        response = self.client.get("/does-NOT-exist/")
+        self.assertEqual(response.status_code, 404)
+
+    def test_redirect(self):
+        Redirect.objects.create(
+            old_path="/A-redirect", redirect_link="/destination", site=None
+        )
+        response = self.client.get("/A-redirect/")
+        self.assertEqual(response.status_code, 301)
+
+    def test_double_slashed_url_for_missing_page(self):
+        response = self.client.get(
+            "http://testserver//evil.com"  # Must be a fully-qualified, as parsing it bypasses the issue we're testing
+        )
+        self.assertEqual(response.status_code, 404)

tbx/core/utils/middleware.py

@@ -0,0 +1,61 @@
+from typing import TYPE_CHECKING, Optional
+
+from django.http import Http404, HttpResponsePermanentRedirect
+
+from wagtail.models import Site
+
+
+if TYPE_CHECKING:
+    from django.http import HttpRequest, HttpResponse
+
+    from wagtail.models import Page
+
+
+class URLCaseNormalizeMiddleware:
+    """
+    If Wagtail can't find a page, this middleware checks whether a lower-case
+    version of the page exists too, and redirects to it
+    """
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def get_page_for_path(self, request: "HttpRequest", path: str) -> Optional["Page"]:
+        """
+        Implementation lifted from `wagtail.views.serve`.
+        """
+        site = Site.find_for_request(request)
+
+        path_components = [component for component in path.split("/") if component]
+
+        try:
+            page, _, _ = site.root_page.localized.specific.route(
+                request, path_components
+            )
+        except Http404:
+            return None
+
+        return page
+
+    def __call__(self, request: "HttpRequest") -> "HttpResponse":
+        response = self.get_response(request)
+
+        if response.status_code != 404:
+            return response
+
+        # If the path is already lower-case, do nothing.
+        if request.path.islower():
+            return response
+
+        # Pre-confirm there's a site for this URL
+        site = Site.find_for_request(request)
+        if not site:
+            return response
+
+        if page := self.get_page_for_path(request, request.path.lower()):
+            query_string = f"?{request.GET.urlencode()}" if request.GET else ""
+            return HttpResponsePermanentRedirect(
+                page.get_url(request=request) + query_string
+            )
+
+        return response

tbx/settings/base.py

@@ -99,6 +99,7 @@
     # Clickjacking prevention. Default: X_FRAME_OPTIONS = 'DENY'
     # See https://docs.djangoproject.com/en/dev/ref/clickjacking/#preventing-clickjacking
     "django.middleware.clickjacking.XFrameOptionsMiddleware",
+    "tbx.core.utils.middleware.URLCaseNormalizeMiddleware",
     "wagtail.contrib.redirects.middleware.RedirectMiddleware",
 ]