wagtail 6.0.1__py3-none-any.whl → 6.1rc1__py3-none-any.whl

wagtail/tests/test_page_privacy.py

@@ -1,5 +1,5 @@
 from django.contrib.auth.models import Group
-from django.test import TestCase
+from django.test import TestCase, override_settings
 
 from wagtail.models import Page, PageViewRestriction
 from wagtail.test.utils import WagtailTestUtils
@@ -79,6 +79,23 @@ class TestPagePrivacy(WagtailTestUtils, TestCase):
             )
             self.assertRedirects(response, "/")
 
+    @override_settings(
+        WAGTAIL_PASSWORD_REQUIRED_TEMPLATE="tests/custom_page_password_required.html"
+    )
+    def test_anonymous_user_must_authenticate_with_custom_password_required_template(
+        self
+    ):
+        response = self.client.get("/secret-plans/")
+
+        self.assertNotEqual(
+            "wagtailcore/password_required.html",
+            response.templates[0].name,
+        )
+        self.assertEqual(
+            "tests/custom_page_password_required.html",
+            response.templates[0].name,
+        )
+
     def test_view_restrictions_apply_to_subpages(self):
         underpants_page = Page.objects.get(
             url_path="/home/secret-plans/steal-underpants/"

wagtail/tests/test_rich_text.py

@@ -5,7 +5,7 @@ from django.test import TestCase, override_settings
 from django.utils import translation
 
 from wagtail.fields import RichTextField
-from wagtail.models import Locale, Page
+from wagtail.models import Locale, Page, Site
 from wagtail.rich_text import RichText, RichTextMaxLengthValidator, expand_db_html
 from wagtail.rich_text.feature_registry import FeatureRegistry
 from wagtail.rich_text.pages import PageLinkHandler
@@ -82,16 +82,34 @@ class TestExtractAttrs(TestCase):
 
 
 class TestExpandDbHtml(TestCase):
-    def test_expand_db_html_with_linktype(self):
-        html = '<a id="1" linktype="document">foo</a>'
-        result = expand_db_html(html)
-        self.assertEqual(result, "<a>foo</a>")
+    fixtures = ["test.json"]
 
     def test_expand_db_html_no_linktype(self):
         html = '<a id="1">foo</a>'
         result = expand_db_html(html)
         self.assertEqual(result, '<a id="1">foo</a>')
 
+    def test_invalid_linktype_set_to_empty_link(self):
+        html = '<a id="1" linktype="invalid">foo</a>'
+        result = expand_db_html(html)
+        self.assertEqual(result, "<a>foo</a>")
+
+    def test_valid_linktype_and_reference(self):
+        html = '<a id="1" linktype="document">foo</a>'
+        result = expand_db_html(html)
+        self.assertEqual(result, '<a href="/documents/1/test.pdf">foo</a>')
+
+    def test_valid_linktype_invalid_reference_set_to_empty_link(self):
+        html = '<a id="9999" linktype="document">foo</a>'
+        result = expand_db_html(html)
+        self.assertEqual(result, "<a>foo</a>")
+
+    def test_no_embedtype_remove_tag(self):
+        self.assertEqual(expand_db_html('<embed id="1" />'), "")
+
+    def test_invalid_embedtype_remove_tag(self):
+        self.assertEqual(expand_db_html('<embed id="1" embedtype="invalid" />'), "")
+
     @patch("wagtail.embeds.embeds.get_embed")
     def test_expand_db_html_with_embed(self, get_embed):
         from wagtail.embeds.models import Embed
@@ -101,6 +119,78 @@ class TestExpandDbHtml(TestCase):
         result = expand_db_html(html)
         self.assertIn("test html", result)
 
+    # Override CACHES so we don't generate any cache-related SQL queries
+    # for page site root paths (tests use DatabaseCache otherwise).
+    @override_settings(
+        CACHES={
+            "default": {
+                "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+            },
+        }
+    )
+    def test_expand_db_html_database_queries_pages(self):
+        Site.clear_site_root_paths_cache()
+
+        with self.assertNumQueries(5):
+            expand_db_html(
+                """
+This rich text has 8 page links, and this test verifies that the code uses the
+minimal number of database queries (5) to expand them.
+
+All of these pages should be retrieved with 4 queries, one to do the base
+Page table lookup and then 1 each for the EventIndex, EventPage, and
+SimplePage tables.
+
+<a linktype="page" id="3">This links to an EventIndex page.</a>
+<a linktype="page" id="4">This links to an EventPage page.</a>
+<a linktype="page" id="5">This links to an EventPage page.</a>
+<a linktype="page" id="6">This links to an EventPage page.</a>
+<a linktype="page" id="9">This links to an EventPage page.</a>
+<a linktype="page" id="12">This links to an EventPage page.</a>
+<a linktype="page" id="7">This links to a SimplePage page.</a>
+<a linktype="page" id="11">This links to a SimplePage page.</a>
+
+Finally there's one additional query needed to do the Site root paths lookup.
+        """
+            )
+
+    def test_expand_db_html_database_queries_documents(self):
+        with self.assertNumQueries(1):
+            expand_db_html(
+                html="""
+This rich text has 2 document links, and this test verifies that the code uses
+the minimal number of database queries (1) to expand them.
+
+Both of these documents should be retrieved with 1 query:
+
+<a linktype="document" id="1">This links to a document.</a>
+<a linktype="document" id="2">This links to another document.</a>
+"""
+            )
+
+    # Disable rendition cache that might be populated by other tests.
+    @override_settings(
+        CACHES={
+            "renditions": {
+                "BACKEND": "django.core.cache.backends.dummy.DummyCache",
+            },
+        }
+    )
+    def test_expand_db_html_database_queries_images(self):
+        with self.assertNumQueries(3):
+            expand_db_html(
+                """
+This rich text has 2 image links, and this test verifies that the code uses the
+minimal number of database queries (3) to expand them.
+
+Both of these images should be retrieved with 3 queries, one to fetch the
+image objects in bulk and then one per image to fetch their renditions:
+
+This is an image: <embed embedtype="image" id="1" format="left" />
+This is another image: <embed embedtype="image" id="2" format="left" />
+        """
+            )
+
 
 class TestRichTextValue(TestCase):
     fixtures = ["test.json"]

wagtail/tests/test_streamfield.py

@@ -16,6 +16,7 @@ from wagtail.models import Page
 from wagtail.rich_text import RichText
 from wagtail.signal_handlers import disable_reference_index_auto_update
 from wagtail.test.testapp.models import (
+    ComplexDefaultStreamPage,
     JSONBlockCountsStreamModel,
     JSONMinMaxCountStreamModel,
     JSONStreamModel,
@@ -236,6 +237,48 @@ class TestStreamValueAccess(TestCase):
         self.assertEqual(fetched_body[1].block_type, "text")
         self.assertEqual(fetched_body[1].value, "bar")
 
+    def test_complex_assignment(self):
+        page = StreamPage(title="Test page", body=[])
+        page.body = [
+            ("rich_text", "<h2>hello world</h2>"),
+            (
+                "books",
+                [
+                    ("title", "Great Expectations"),
+                    ("author", "Charles Dickens"),
+                ],
+            ),
+        ]
+        self.assertEqual(page.body[0].block_type, "rich_text")
+        self.assertIsInstance(page.body[0].value, RichText)
+        self.assertEqual(page.body[0].value.source, "<h2>hello world</h2>")
+        self.assertEqual(page.body[1].block_type, "books")
+        self.assertIsInstance(page.body[1].value, StreamValue)
+        self.assertEqual(len(page.body[1].value), 2)
+        self.assertEqual(page.body[1].value[0].block_type, "title")
+        self.assertEqual(page.body[1].value[0].value, "Great Expectations")
+        self.assertEqual(page.body[1].value[1].block_type, "author")
+        self.assertEqual(page.body[1].value[1].value, "Charles Dickens")
+
+
+class TestComplexDefault(TestCase):
+    def setUp(self):
+        self.page = ComplexDefaultStreamPage(title="Test page")
+
+    def test_default_value(self):
+        self.assertEqual(self.page.body[0].block_type, "rich_text")
+        self.assertIsInstance(self.page.body[0].value, RichText)
+        self.assertEqual(
+            self.page.body[0].value.source, "<p>My <i>lovely</i> books</p>"
+        )
+        self.assertEqual(self.page.body[1].block_type, "books")
+        self.assertIsInstance(self.page.body[1].value, StreamValue)
+        self.assertEqual(len(self.page.body[1].value), 2)
+        self.assertEqual(self.page.body[1].value[0].block_type, "title")
+        self.assertEqual(self.page.body[1].value[0].value, "The Great Gatsby")
+        self.assertEqual(self.page.body[1].value[1].block_type, "author")
+        self.assertEqual(self.page.body[1].value[1].value, "F. Scott Fitzgerald")
+
 
 class TestStreamFieldRenderingBase(TestCase):
     model = JSONStreamModel

wagtail/tests/test_utils.py

@@ -178,14 +178,14 @@ class TestInvokeViaAttributeShortcut(SimpleTestCase):
             pickled = pickle.dumps(self.test_object, -1)
         except Exception as e:  # noqa: BLE001
             raise AssertionError(
-                "An error occured when attempting to pickle %r: %s"
+                "An error occurred when attempting to pickle %r: %s"
                 % (self.test_object, e)
             )
         try:
             self.test_object = pickle.loads(pickled)
         except Exception as e:  # noqa: BLE001
             raise AssertionError(
-                "An error occured when attempting to unpickle %r: %s"
+                "An error occurred when attempting to unpickle %r: %s"
                 % (self.test_object, e)
             )
 
@@ -479,6 +479,12 @@ class TestGetDummyRequest(TestCase):
         request = get_dummy_request(site=site)
         self.assertEqual(request.get_host(), "other.example.com:8888")
 
+    def test_server_name_for_wildcard_allowed_hosts(self):
+        # Django's test runner adds "testserver" at the end of ALLOWED_HOSTS.
+        with self.settings(ALLOWED_HOSTS=["*", "testserver"]):
+            request = get_dummy_request()
+            self.assertEqual(request.get_host(), "example.com")
+
 
 class TestDeepUpdate(TestCase):
     def test_deep_update(self):

wagtail/tests/test_views.py

@@ -1,8 +1,13 @@
+from unittest import mock
+
 from django.test import TestCase
 from django.urls import reverse
 
-from wagtail.models import Page
+from wagtail.coreutils import get_dummy_request
+from wagtail.models import Page, Site
+from wagtail.test.testapp.models import SimplePage
 from wagtail.test.utils import WagtailTestUtils
+from wagtail.views import serve
 
 
 class TestLoginView(WagtailTestUtils, TestCase):
@@ -47,3 +52,49 @@ class TestLoginView(WagtailTestUtils, TestCase):
             },
         )
         self.assertRedirects(response, self.events_index.url)
+
+
+@mock.patch("wagtail.hooks.get_hooks", mock.Mock(return_value=[]))
+class TestServeView(TestCase):
+    fixtures = ["test.json"]
+
+    def test_serve_query_count(self):
+        request = get_dummy_request()
+        Site.find_for_request(request)
+        page, args, kwargs = Page.route_for_request(request, request.path)
+        with mock.patch.object(page, "serve", wraps=page.serve) as m:
+            with self.assertNumQueries(0):
+                serve(request, "/")
+            m.assert_called_once_with(request, *args, **kwargs)
+
+    def test_process_view_by_page_query_count(self):
+        expected_query_count = 3
+        site = Site.objects.get()
+        page = site.root_page.add_child(
+            instance=SimplePage(title="Simple page", slug="simple", content="Simple")
+        )
+        with mock.patch.object(
+            Page, "route_for_request", wraps=Page.route_for_request
+        ) as m:
+            with self.modify_settings(
+                MIDDLEWARE={
+                    "prepend": "wagtail.test.middleware.SimplePageViewInterceptorMiddleware"
+                }
+            ):
+                with self.assertNumQueries(expected_query_count):
+                    response_a = self.client.get("/simple/")
+                self.assertEqual(
+                    response_a.content,
+                    b'\n\n\n\n<!DOCTYPE HTML>\n<html lang="en" dir="ltr">\n    <head>\n        <title>Simple page</title>\n    </head>\n    <body>\n        \n        <h1>Simple page</h1>\n        \n    <h2>Simple page</h2>\n\n    </body>\n</html>\n',
+                )
+                self.assertEqual(m.call_count, 2)
+                page.content = "Intercept me"
+                page.save_revision().publish()
+                m.reset_mock()
+                with self.assertNumQueries(expected_query_count):
+                    # verify the same number of queries are used when the
+                    # middleware activates to demonstrate Page.route_for_request()
+                    # prevents extra database queries for serving pages
+                    response_b = self.client.get("/simple/")
+                self.assertEqual(response_b.content, b"Intercepted")
+                self.assertEqual(m.call_count, 1)

wagtail/tests/test_whitelist.py

@@ -28,7 +28,7 @@ class TestCheckUrl(TestCase):
 
 class TestAttributeRule(WagtailTestUtils, TestCase):
     def setUp(self):
-        self.soup = self.get_soup('<b foo="bar">baz</b>', "html5lib")
+        self.soup = self.get_soup('<b foo="bar">baz</b>')
 
     def test_no_rule_for_attr(self):
         """
@@ -88,7 +88,7 @@ class TestAttributeRule(WagtailTestUtils, TestCase):
         attributes.
         """
         soup = self.get_soup(
-            '<b foo="bar" baz="quux" snowman="barbecue"></b>', "html5lib"
+            '<b foo="bar" baz="quux" snowman="barbecue"></b>',
         )
         tag = soup.b
         allow_without_attributes(tag)
@@ -103,7 +103,7 @@ class TestWhitelister(WagtailTestUtils, TestCase):
         """
         Unknown node should remove a node from the parent document
         """
-        soup = self.get_soup("<foo><bar>baz</bar>quux</foo>", "html5lib")
+        soup = self.get_soup("<foo><bar>baz</bar>quux</foo>")
         tag = soup.foo
         self.whitelister.clean_unknown_node("", soup.bar)
         self.assertEqual(str(tag), "<foo>quux</foo>")
@@ -113,7 +113,7 @@ class TestWhitelister(WagtailTestUtils, TestCase):
         <b> tags are allowed without attributes. This remains true
         when tags are nested.
         """
-        soup = self.get_soup('<b><b class="delete me">foo</b></b>', "html5lib")
+        soup = self.get_soup('<b><b class="delete me">foo</b></b>')
         tag = soup.b
         self.whitelister.clean_tag_node(tag, tag)
         self.assertEqual(str(tag), "<b><b>foo</b></b>")
@@ -122,19 +122,19 @@ class TestWhitelister(WagtailTestUtils, TestCase):
         """
         <foo> tags should be removed, even when nested.
         """
-        soup = self.get_soup("<b><foo>bar</foo></b>", "html5lib")
+        soup = self.get_soup("<b><foo>bar</foo></b>")
         tag = soup.b
         self.whitelister.clean_tag_node(tag, tag)
         self.assertEqual(str(tag), "<b>bar</b>")
 
     def test_clean_string_node_does_nothing(self):
-        soup = self.get_soup("<b>bar</b>", "html5lib")
+        soup = self.get_soup("<b>bar</b>")
         string = soup.b.string
         self.whitelister.clean_string_node(string, string)
         self.assertEqual(str(string), "bar")
 
     def test_clean_node_does_not_change_navigable_strings(self):
-        soup = self.get_soup("<b>bar</b>", "html5lib")
+        soup = self.get_soup("<b>bar</b>")
         string = soup.b.string
         self.whitelister.clean_node(string, string)
         self.assertEqual(str(string), "bar")

wagtail/users/forms.py

@@ -297,7 +297,9 @@ class PagePermissionsForm(forms.Form):
             content_type__app_label="wagtailcore",
             content_type__model="page",
             codename__in=PAGE_PERMISSION_CODENAMES,
-        ).order_by("codename"),
+        )
+        .select_related("content_type")
+        .order_by("codename"),
         # Use codename as the field to use for the option values rather than pk,
         # to minimise the changes needed since we moved to the Permission model
         # and to ease testing.