wagtail 6.3.2__py3-none-any.whl → 6.4__py3-none-any.whl

wagtail/tests/test_hooks.py

@@ -1,7 +1,14 @@
-from django.test import TestCase
+from unittest import mock
+
+from django.contrib.sessions.middleware import SessionMiddleware
+from django.http import HttpResponse
+from django.test import RequestFactory, TestCase
 
 from wagtail import hooks
+from wagtail.models import Page, PageViewRestriction
 from wagtail.test.utils import WagtailTestUtils
+from wagtail.views import serve, serve_chain
+from wagtail.wagtail_hooks import check_view_restrictions
 
 
 def test_hook():
@@ -34,3 +41,161 @@ class TestLoginView(WagtailTestUtils, TestCase):
         with self.register_hook("test_hook_name", after_hook, order=1):
             hook_fns = hooks.get_hooks("test_hook_name")
             self.assertEqual(hook_fns, [test_hook, after_hook])
+
+
+class TestServeHooks(WagtailTestUtils, TestCase):
+    fixtures = ["test.json"]
+
+    def setUp(self):
+        self.page = Page.objects.get(id=2)
+        self.request = RequestFactory().get("/test/")
+        middleware = SessionMiddleware(lambda x: None)
+        middleware.process_request(self.request)
+        self.request.session.save()
+
+    def test_serve_chain_order(self):
+        order_calls = []
+
+        def hook_1(next_fn):
+            def wrapper(page, request, *args, **kwargs):
+                order_calls.append(1)
+                return next_fn(page, request, *args, **kwargs)
+
+            return wrapper
+
+        def hook_2(next_fn):
+            def wrapper(page, request, *args, **kwargs):
+                order_calls.append(2)
+                return next_fn(page, request, *args, **kwargs)
+
+            return wrapper
+
+        def hook_3(next_fn):
+            def wrapper(page, request, *args, **kwargs):
+                order_calls.append(3)
+                return next_fn(page, request, *args, **kwargs)
+
+            return wrapper
+
+        with self.register_hook("on_serve_page", hook_1):
+            with self.register_hook("on_serve_page", hook_2):
+                with self.register_hook("on_serve_page", hook_3):
+                    serve(self.request, self.page.url)
+
+                    self.assertEqual(order_calls, [1, 2, 3])
+
+    def test_serve_chain_modification(self):
+        def hook_modifier(next_fn):
+            def wrapper(page, request, *args, **kwargs):
+                response = next_fn(page, request, *args, **kwargs)
+                response.content = b"Modified content"
+                return response
+
+            return wrapper
+
+        with self.register_hook("on_serve_page", hook_modifier):
+            response = serve(self.request, self.page.url)
+            self.assertEqual(response.content, b"Modified content")
+
+    def test_serve_chain_halt_execution(self):
+        def hook_halt(next_fn):
+            def wrapper(page, request, *args, **kwargs):
+                return HttpResponse("Halted")
+
+            return wrapper
+
+        with self.register_hook("on_serve_page", hook_halt):
+            response = serve(self.request, self.page.url)
+            self.assertEqual(response.content, b"Halted")
+
+    def test_serve_chain_view_restriction(self):
+        restriction = PageViewRestriction.objects.create(
+            page=self.page,
+            restriction_type=PageViewRestriction.PASSWORD,
+            password="password",
+        )
+
+        with self.register_hook("on_serve_page", check_view_restrictions):
+            response = self.client.get(self.page.url)
+            self.assertEqual(response.status_code, 200)
+            self.assertTemplateUsed(response, "wagtailcore/password_required.html")
+
+        restriction.delete()
+
+    def test_serve_always_called_last(self):
+        hook_calls = []
+        serve_called = []
+
+        def hook_1(next_fn):
+            def wrapper(page, request, *args, **kwargs):
+                hook_calls.append(1)
+                return next_fn(page, request, *args, **kwargs)
+
+            return wrapper
+
+        def hook_2(next_fn):
+            def wrapper(page, request, *args, **kwargs):
+                hook_calls.append(2)
+                return next_fn(page, request, *args, **kwargs)
+
+            return wrapper
+
+        def hook_3(next_fn):
+            def wrapper(page, request, *args, **kwargs):
+                hook_calls.append(3)
+                return next_fn(page, request, *args, **kwargs)
+
+            return wrapper
+
+        original_serve_chain = serve_chain
+
+        def mock_serve_chain(page, request, *args, **kwargs):
+            serve_called.append(True)
+            return original_serve_chain(page, request, *args, **kwargs)
+
+        with mock.patch("wagtail.views.serve_chain", mock_serve_chain):
+            with self.register_hook("on_serve_page", hook_1):
+                with self.register_hook("on_serve_page", hook_2):
+                    with self.register_hook("on_serve_page", hook_3):
+                        serve(self.request, self.page.url)
+
+                        self.assertEqual(hook_calls, [1, 2, 3])
+                        self.assertEqual(len(serve_called), 1)
+                        self.assertTrue(serve_called[0])
+
+    def test_check_view_restrictions_receives_correct_parameters(self):
+        received_params = []
+
+        def hook_spy(next_fn):
+            def wrapper(page, request, *args, **kwargs):
+                received_params.append(
+                    {"page": page, "request": request, "args": args, "kwargs": kwargs}
+                )
+                return next_fn(page, request, *args, **kwargs)
+
+            return wrapper
+
+        self.assertIsNotNone(self.page, "Test page should not be None")
+        self.assertIsNotNone(self.request, "Test request should not be None")
+
+        with self.register_hook("on_serve_page", hook_spy):
+            route_result = Page.route_for_request(self.request, self.page.url)
+
+            self.assertIsNotNone(route_result, "route_result should not be None")
+
+            if route_result:
+                page, args, kwargs = route_result
+                serve(self.request, self.page.url)
+
+                self.assertEqual(len(received_params), 1)
+
+                params = received_params[0]
+
+                self.assertIsNotNone(params["page"], "Hook received None as page")
+                self.assertIsNotNone(params["request"], "Hook received None as request")
+
+                self.assertEqual(params["page"], self.page)
+                self.assertEqual(params["request"], self.request)
+
+                self.assertEqual(params["args"], ([], {}))
+                self.assertEqual(params["kwargs"], {})

wagtail/tests/test_management_commands.py

@@ -5,6 +5,7 @@ from unittest import mock
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import Group
 from django.core import management
+from django.core.cache import cache
 from django.db import models
 from django.test import TestCase, override_settings
 from django.utils import timezone
@@ -177,10 +178,19 @@ class TestSetUrlPathsCommand(TestCase):
         self.run_command()
 
 
+@override_settings(
+    CACHES={
+        "default": {
+            "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+        },
+    }
+)
 class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
     fixtures = ["test.json"]
 
     def setUp(self):
+        cache.clear()
+
         # Find root page
         self.root_page = Page.objects.get(id=2)
 
@@ -215,8 +225,9 @@ class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
                 .exclude(approved_go_live_at__isnull=True)
                 .exists()
             )
-
-            management.call_command("publish_scheduled_pages")
+            with self.assertNumQueries(49):
+                with self.captureOnCommitCallbacks(execute=True):
+                    management.call_command("publish_scheduled_pages")
 
             p = Page.objects.get(slug="hello-world")
             self.assertTrue(p.live)
@@ -272,7 +283,9 @@ class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
                 .exists()
             )
 
-            management.call_command("publish_scheduled_pages")
+            with self.assertNumQueries(49):
+                with self.captureOnCommitCallbacks(execute=True):
+                    management.call_command("publish_scheduled_pages")
 
             p = Page.objects.get(slug="hello-world")
             self.assertTrue(p.live)
@@ -307,7 +320,9 @@ class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
         page.title = "Goodbye world!"
         page.save_revision()
 
-        management.call_command("publish_scheduled_pages")
+        with self.assertNumQueries(49):
+            with self.captureOnCommitCallbacks(execute=True):
+                management.call_command("publish_scheduled_pages")
 
         p = Page.objects.get(slug="hello-world")
         self.assertTrue(p.live)
@@ -334,7 +349,9 @@ class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
             .exists()
         )
 
-        management.call_command("publish_scheduled_pages")
+        with self.assertNumQueries(47):
+            with self.captureOnCommitCallbacks(execute=True):
+                management.call_command("publish_scheduled_pages")
 
         p = Page.objects.get(slug="hello-world")
         self.assertFalse(p.live)
@@ -369,7 +386,9 @@ class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
             p = Page.objects.get(slug="hello-world")
             self.assertTrue(p.live)
 
-            management.call_command("publish_scheduled_pages")
+            with self.assertNumQueries(29):
+                with self.captureOnCommitCallbacks(execute=True):
+                    management.call_command("publish_scheduled_pages")
 
             p = Page.objects.get(slug="hello-world")
             self.assertFalse(p.live)
@@ -396,17 +415,27 @@ class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
         p = Page.objects.get(slug="hello-world")
         self.assertTrue(p.live)
 
-        management.call_command("publish_scheduled_pages")
+        with self.assertNumQueries(6):
+            with self.captureOnCommitCallbacks(execute=True):
+                management.call_command("publish_scheduled_pages")
 
         p = Page.objects.get(slug="hello-world")
         self.assertTrue(p.live)
         self.assertFalse(p.expired)
 
 
+@override_settings(
+    CACHES={
+        "default": {
+            "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+        },
+    }
+)
 class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
     fixtures = ["test.json"]
 
     def setUp(self):
+        cache.clear()
         self.snippet = DraftStateModel.objects.create(text="Hello world!", live=False)
 
     def test_go_live_will_be_published(self):
@@ -435,7 +464,9 @@ class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
                 .exists()
             )
 
-            management.call_command("publish_scheduled")
+            with self.assertNumQueries(15):
+                with self.captureOnCommitCallbacks(execute=True):
+                    management.call_command("publish_scheduled")
 
             self.snippet.refresh_from_db()
             self.assertTrue(self.snippet.live)
@@ -482,7 +513,9 @@ class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
                 .exists()
             )
 
-            management.call_command("publish_scheduled")
+            with self.assertNumQueries(15):
+                with self.captureOnCommitCallbacks(execute=True):
+                    management.call_command("publish_scheduled")
 
             self.snippet.refresh_from_db()
             self.assertTrue(self.snippet.live)
@@ -510,7 +543,9 @@ class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
         self.snippet.text = "Goodbye world!"
         self.snippet.save_revision()
 
-        management.call_command("publish_scheduled")
+        with self.assertNumQueries(15):
+            with self.captureOnCommitCallbacks(execute=True):
+                management.call_command("publish_scheduled")
 
         self.snippet.refresh_from_db()
         self.assertTrue(self.snippet.live)
@@ -533,7 +568,9 @@ class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
             .exists()
         )
 
-        management.call_command("publish_scheduled")
+        with self.assertNumQueries(14):
+            with self.captureOnCommitCallbacks(execute=True):
+                management.call_command("publish_scheduled")
 
         self.assertFalse(self.snippet.live)
         self.assertTrue(
@@ -560,7 +597,9 @@ class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
             self.snippet.refresh_from_db()
             self.assertTrue(self.snippet.live)
 
-            management.call_command("publish_scheduled")
+            with self.assertNumQueries(10):
+                with self.captureOnCommitCallbacks(execute=True):
+                    management.call_command("publish_scheduled")
 
             self.snippet.refresh_from_db()
             self.assertFalse(self.snippet.live)
@@ -580,7 +619,9 @@ class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
         self.snippet.refresh_from_db()
         self.assertTrue(self.snippet.live)
 
-        management.call_command("publish_scheduled")
+        with self.assertNumQueries(6):
+            with self.captureOnCommitCallbacks(execute=True):
+                management.call_command("publish_scheduled")
 
         self.snippet.refresh_from_db()
         self.assertTrue(self.snippet.live)

wagtail/tests/test_page_allowed_http_methods.py

@@ -0,0 +1,32 @@
+from django.test import TestCase
+
+from wagtail.models import Page, Site
+from wagtail.test.testapp.models import EventIndex
+
+
+class AllowedHttpMethodsTestCase(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        super().setUpTestData()
+        site = Site.objects.select_related("root_page").get(is_default_site=True)
+        cls.page = Page(title="Page", slug="page")
+        site.root_page.add_child(instance=cls.page)
+        cls.event_index_page = EventIndex(title="Event index", slug="event-index")
+        site.root_page.add_child(instance=cls.event_index_page)
+
+    def test_options_request_for_default_page(self):
+        response = self.client.options(self.page.url)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            response["Allow"], "DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT"
+        )
+
+    def test_options_request_for_restricted_page(self):
+        response = self.client.options(self.event_index_page.url)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response["Allow"], "GET, OPTIONS")
+
+    def test_invalid_request_method_for_restricted_page(self):
+        response = self.client.post(self.event_index_page.url)
+        self.assertEqual(response.status_code, 405)
+        self.assertEqual(response["Allow"], "GET, OPTIONS")

wagtail/tests/test_page_model.py

@@ -10,6 +10,7 @@ from django.core.exceptions import ValidationError
 from django.http import Http404
 from django.test import Client, TestCase, override_settings
 from django.test.client import RequestFactory
+from django.urls import reverse
 from django.utils import timezone, translation
 from freezegun import freeze_time
 
@@ -326,6 +327,12 @@ class TestSiteRouting(TestCase):
                 Site.find_for_request(request), self.alternate_port_events_site
             )
 
+    def test_site_with_disallowed_host(self):
+        request = get_dummy_request()
+        request.META["HTTP_HOST"] = "disallowed:80"
+        with self.assertNumQueries(1):
+            self.assertEqual(Site.find_for_request(request), self.default_site)
+
 
 class TestRouting(TestCase):
     fixtures = ["test.json"]
@@ -3994,3 +4001,64 @@ class TestPageCachedParentObjExists(TestCase):
             "_cached_parent_obj_exists",
             "Page.get_parent() (treebeard) no longer uses _cached_parent_obj to cache the parent object",
         )
+
+
+class TestPageServeWithPasswordRestriction(TestCase, WagtailTestUtils):
+    def setUp(self):
+        self.root_page = Page.objects.get(id=2)
+        self.test_page = Page(
+            title="Test Page",
+            slug="test",
+        )
+        self.root_page.add_child(instance=self.test_page)
+
+        self.password_restriction = PageViewRestriction.objects.create(
+            page=self.test_page,
+            restriction_type=PageViewRestriction.PASSWORD,
+            password="password123",
+        )
+
+    def test_page_with_password_restriction_authenticated_has_cache_headers(self):
+        auth_url = reverse(
+            "wagtailcore_authenticate_with_password",
+            args=[self.password_restriction.id, self.test_page.id],
+        )
+
+        post_response = self.client.post(
+            auth_url,
+            {
+                "password": "password123",
+                "return_url": "/test/",
+            },
+        )
+
+        self.assertRedirects(post_response, "/test/")
+
+        response = self.client.get("/test/")
+
+        self.assertTrue("Cache-Control" in response)
+        self.assertIn("max-age=0", response["Cache-Control"])
+        self.assertIn("no-cache", response["Cache-Control"])
+        self.assertIn("no-store", response["Cache-Control"])
+        self.assertIn("must-revalidate", response["Cache-Control"])
+        self.assertIn("private", response["Cache-Control"])
+        self.assertTrue("Expires" in response)
+
+    def test_page_with_password_restriction_has_cache_headers(self):
+        response = self.client.get("/test/")
+
+        self.assertTrue("Cache-Control" in response)
+        self.assertIn("max-age=0", response["Cache-Control"])
+        self.assertIn("no-cache", response["Cache-Control"])
+        self.assertIn("no-store", response["Cache-Control"])
+        self.assertIn("must-revalidate", response["Cache-Control"])
+        self.assertIn("private", response["Cache-Control"])
+        self.assertTrue("Expires" in response)
+
+    def test_page_without_password_restriction_has_no_cache_headers(self):
+        self.password_restriction.delete()
+
+        response = self.client.get("/test/")
+
+        self.assertFalse("Cache-Control" in response)
+        self.assertFalse("Expires" in response)

wagtail/tests/test_page_privacy.py

@@ -231,3 +231,13 @@ class TestPagePrivacy(WagtailTestUtils, TestCase):
         response = self.client.get("/secret-login-plans/")
         self.assertEqual(response.status_code, 200)
         self.assertContains(response, "<title>Secret login plans</title>")
+
+    def test_password_protected_page_headers(self):
+        response = self.client.get("/secret-plans/")
+        self.assertEqual(
+            response.templates[0].name, "wagtailcore/password_required.html"
+        )
+        self.assertIn("no-cache", response["Cache-Control"])
+        self.assertIn("no-store", response["Cache-Control"])
+        self.assertIn("must-revalidate", response["Cache-Control"])
+        self.assertIn("max-age=0", response["Cache-Control"])

wagtail/tests/test_page_queryset.py

@@ -919,6 +919,85 @@ class TestSpecificQuery(WagtailTestUtils, TestCase):
         self.assertEqual(results.first().subscribers_count, 1)
         self.assertEqual(results.last().subscribers_count, 1)
 
+    def test_specific_subquery_select_related(self):
+        with self.assertNumQueries(2):
+            pages = list(
+                Page.objects.type(EventPage)
+                .specific()
+                .select_related("feed_image", for_specific_subqueries=True)
+            )
+        self.assertEqual(len(pages), 4)
+        with self.assertNumQueries(0):
+            for page in pages:
+                self.assertTrue(page.feed_image)
+
+    def test_specific_subquery_select_related_without_fields(
+        self,
+    ):
+        with self.assertRaises(ValueError):
+            Page.objects.all().select_related(for_specific_subqueries=True)
+
+    def test_specific_subquery_select_related_negation(self):
+        with self.assertNumQueries(2):
+            pages = list(
+                Page.objects.type(EventPage)
+                .specific()
+                .select_related("feed_image", for_specific_subqueries=True)
+                .select_related(
+                    None, for_specific_subqueries=True
+                )  # This should negate the above line
+            )
+        with self.assertNumQueries(4):
+            for page in pages:
+                self.assertTrue(page.feed_image)
+
+    def test_specific_subquery_prefetch_related(self):
+        with self.assertNumQueries(3):
+            pages = list(
+                Page.objects.type(EventPage)
+                .specific()
+                .prefetch_related("categories", for_specific_subqueries=True)
+            )
+        self.assertEqual(len(pages), 4)
+        with self.assertNumQueries(0):
+            for page in pages:
+                self.assertFalse(page.categories.all())
+
+    def test_specific_subquery_prefetch_related_without_lookups(self):
+        with self.assertRaises(ValueError):
+            Page.objects.all().prefetch_related(for_specific_subqueries=True)
+
+    def test_specific_subquery_prefetch_related_negation(self):
+        with self.assertNumQueries(2):
+            pages = list(
+                Page.objects.type(EventPage)
+                .specific()
+                .prefetch_related("categories", for_specific_subqueries=True)
+                .prefetch_related(
+                    None, for_specific_subqueries=True
+                )  # This should negate the above line
+            )
+        self.assertEqual(len(pages), 4)
+        with self.assertNumQueries(4):
+            for page in pages:
+                self.assertFalse(page.categories.all())
+
+    def test_specific_subquery_select_related_and_prefetch_related(self):
+        with self.assertNumQueries(3):
+            pages = list(
+                Page.objects.type(EventPage)
+                .specific()
+                .select_related("feed_image", for_specific_subqueries=True)
+                .prefetch_related(
+                    "feed_image__renditions", for_specific_subqueries=True
+                )
+            )
+        self.assertEqual(len(pages), 4)
+        with self.assertNumQueries(0):
+            for page in pages:
+                self.assertTrue(page.feed_image)
+                self.assertFalse(page.feed_image.renditions.all())
+
     def test_specific_query_with_alias(self):
         """
         Ensure alias() works with specific() queries.