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

wagtail/admin/tests/test_block_preview.py

@@ -0,0 +1,228 @@
+from django.contrib.auth.models import Permission
+from django.http import HttpRequest
+from django.test import TestCase
+from django.urls import reverse
+from django.utils.http import urlencode
+
+from wagtail import blocks
+from wagtail.test.utils import WagtailTestUtils
+
+
+class TestStreamFieldBlockPreviewView(WagtailTestUtils, TestCase):
+    def get(self, block):
+        return self.client.get(
+            reverse("wagtailadmin_block_preview"),
+            {"id": block.definition_prefix},
+        )
+
+    def setUp(self):
+        self.user = self.login()
+
+    def test_simple(self):
+        block = blocks.CharBlock(
+            label="Single-line text",
+            description="A single line of text",
+            preview_value="Hello, world!",
+        )
+        block.set_name("single_line_text")
+        response = self.get(block)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+
+        html = soup.select_one("html")
+        self.assertIsNotNone(html)
+        self.assertEqual(html["lang"], "en")
+        self.assertEqual(html["dir"], "ltr")
+
+        robots = soup.select_one("meta[name=robots]")
+        self.assertIsNotNone(robots)
+        self.assertEqual(robots["content"], "noindex")
+
+        title = soup.select_one("title")
+        self.assertIsNotNone(title)
+        self.assertEqual(title.text.strip(), "Preview for Single-line text (CharBlock)")
+
+        main = soup.select_one("main")
+        self.assertIsNotNone(main)
+        self.assertEqual(main.text.strip(), "Hello, world!")
+
+        wrapper = main.select_one("div.block-single_line_text")
+        self.assertIsNotNone(wrapper)
+
+    def test_nonexisting_block(self):
+        response = self.client.get(reverse("wagtailadmin_block_preview"))
+        self.assertEqual(response.status_code, 404)
+
+        response = self.client.get(
+            reverse("wagtailadmin_block_preview"),
+            {"id": "nonexisting"},
+        )
+        self.assertEqual(response.status_code, 404)
+
+    def test_no_admin_permission(self):
+        self.user.is_superuser = False
+        self.user.save()
+
+        block = blocks.CharBlock()
+        response = self.get(block)
+        self.assertRedirects(
+            response,
+            reverse("wagtailadmin_login")
+            + "?"
+            + urlencode({"next": response.wsgi_request.get_full_path()}),
+        )
+
+    def test_minimal_permission(self):
+        self.user.is_superuser = False
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                content_type__app_label="wagtailadmin",
+                codename="access_admin",
+            )
+        )
+        self.user.save()
+
+        block = blocks.CharBlock(preview_value="Hello, world!")
+        response = self.get(block)
+        self.assertEqual(response.status_code, 200)
+
+    def test_no_preview_value_no_default(self):
+        block = blocks.Block()
+        response = self.get(block)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        main = soup.select_one("main")
+        self.assertIsNotNone(main)
+        self.assertEqual(main.text.strip(), "None")
+
+    def test_preview_value_falls_back_to_default(self):
+        block = blocks.IntegerBlock(default=42)
+        response = self.get(block)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        main = soup.select_one("main")
+        self.assertIsNotNone(main)
+        self.assertEqual(main.text.strip(), "42")
+
+    def test_preview_template(self):
+        class PreviewTemplateViaMeta(blocks.Block):
+            class Meta:
+                preview_template = "tests/custom_block_preview.html"
+
+        class PreviewTemplateViaMethod(blocks.Block):
+            def get_preview_template(self, value=None, context=None):
+                return "tests/custom_block_preview.html"
+
+        cases = [
+            ("meta", PreviewTemplateViaMeta()),
+            ("method", PreviewTemplateViaMethod()),
+            ("kwarg", blocks.Block(preview_template="tests/custom_block_preview.html")),
+        ]
+
+        for via, block in cases:
+            with self.subTest(via=via):
+                response = self.get(block)
+                self.assertEqual(response.status_code, 200)
+                self.assertTemplateUsed(response, "tests/custom_block_preview.html")
+
+                response = self.get(block)
+                self.assertEqual(response.status_code, 200)
+                self.assertTemplateUsed(response, "tests/custom_block_preview.html")
+
+                soup = self.get_soup(response.content)
+                custom_wrapper = soup.select_one("main .my-preview-wrapper")
+                self.assertIsNotNone(custom_wrapper)
+
+                custom_css = soup.select_one("link[rel=stylesheet]")
+                self.assertIsNotNone(custom_css)
+                self.assertEqual(custom_css["href"], "/static/css/custom.css")
+
+                custom_js = soup.select_one("script[src]")
+                self.assertIsNotNone(custom_js)
+                self.assertEqual(custom_js["src"], "/static/js/custom.js")
+
+    def test_preview_value(self):
+        class PreviewValueViaMeta(blocks.Block):
+            class Meta:
+                preview_value = "Hello, world!"
+
+        class PreviewValueViaMethod(blocks.Block):
+            def get_preview_value(self):
+                return "Hello, world!"
+
+        cases = [
+            ("meta", PreviewValueViaMeta()),
+            ("method", PreviewValueViaMethod()),
+            ("kwarg", blocks.Block(preview_value="Hello, world!")),
+        ]
+
+        for via, block in cases:
+            with self.subTest(via=via):
+                response = self.get(block)
+                self.assertEqual(response.status_code, 200)
+                soup = self.get_soup(response.content)
+                main = soup.select_one("main")
+                self.assertIsNotNone(main)
+                self.assertEqual(main.text.strip(), "Hello, world!")
+
+    def test_custom_preview_context(self):
+        preview_value = "With a custom context"
+        label = "Fancy block"
+
+        class CustomPreviewContextBlock(blocks.Block):
+            def get_preview_context(block, value, parent_context=None):
+                self.assertEqual(value, preview_value)
+                self.assertIsNotNone(parent_context)
+                self.assertIsInstance(parent_context.get("request"), HttpRequest)
+                self.assertIs(parent_context.get("block_def"), block)
+                self.assertIs(
+                    parent_context.get("block_class"),
+                    CustomPreviewContextBlock,
+                )
+                self.assertIsInstance(
+                    parent_context.get("bound_block"),
+                    blocks.BoundBlock,
+                )
+                self.assertEqual(
+                    parent_context.get("page_title"),
+                    "Preview for Fancy block (CustomPreviewContextBlock)",
+                )
+                return {
+                    **parent_context,
+                    "extra": "Added by get_preview_context",
+                    "page_title": "Custom title",
+                }
+
+        block = CustomPreviewContextBlock(label=label, preview_value=preview_value)
+        response = self.get(block)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        main = soup.select_one("main")
+        self.assertIsNotNone(main)
+        self.assertEqual(main.text.strip(), preview_value)
+        # Ensure custom context can add and override values
+        self.assertEqual(response.context["extra"], "Added by get_preview_context")
+        self.assertEqual(response.context["page_title"], "Custom title")
+        # Ensure that the default context is still present
+        self.assertIs(response.context["block_def"], block)
+
+    def test_static_image_preview(self):
+        class StaticImagePreviewBlock(blocks.Block):
+            def get_preview_context(self, value, parent_context=None):
+                return {
+                    "image_path": "block_previews/preview.jpg",
+                    "image_description": "A preview of the block",
+                }
+
+            class Meta:
+                preview_template = "tests/static_block_preview.html"
+
+        block = StaticImagePreviewBlock()
+        response = self.get(block)
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "tests/static_block_preview.html")
+        soup = self.get_soup(response.content)
+        img = soup.select_one("html body main img")
+        self.assertIsNotNone(img)
+        self.assertEqual(img["src"], "/static/block_previews/preview.jpg")
+        self.assertEqual(img["alt"], "A preview of the block")

wagtail/admin/tests/test_edit_handlers.py

@@ -30,6 +30,7 @@ from wagtail.admin.panels import (
     PublishingPanel,
     TabbedInterface,
     TitleFieldPanel,
+    expand_panel_list,
     extract_panel_definitions_from_model_class,
     get_form_for_model,
 )
@@ -1523,6 +1524,13 @@ class TestInlinePanel(WagtailTestUtils, TestCase):
                 ),
             )
 
+    def test_get_heading_and_label_from_field(self):
+        panel = InlinePanel("social_links").bind_to_model(PersonPage)
+        # Heading is the plural term, derived from the relation's related_name
+        self.assertEqual(panel.heading, "Social links")
+        # Label is the singular term, derived from the related model's verbose_name
+        self.assertEqual(panel.label, "Social link")
+
 
 class TestNonOrderableInlinePanel(WagtailTestUtils, TestCase):
     fixtures = ["test.json"]
@@ -1569,7 +1577,7 @@ class TestInlinePanelGetComparison(TestCase):
         self.request.user = user
 
     def test_get_comparison(self):
-        # Test whether the InlinePanel passes it's label in get_comparison
+        # Test whether the InlinePanel passes its heading as the label in get_comparison
 
         page = Page.objects.get(id=4).specific
         comparison = (
@@ -1580,7 +1588,7 @@ class TestInlinePanelGetComparison(TestCase):
 
         comparison = [comp(page, page) for comp in comparison]
         field_labels = [comp.field_label() for comp in comparison]
-        self.assertIn("Speakers", field_labels)
+        self.assertIn("Speaker lineup", field_labels)
 
 
 class TestInlinePanelRelatedModelPanelConfigChecks(TestCase):
@@ -1719,7 +1727,10 @@ class TestCommentPanel(WagtailTestUtils, TestCase):
         Test that the comment panel is missing if WAGTAILADMIN_COMMENTS_ENABLED=False
         """
         self.assertFalse(
-            any(isinstance(panel, CommentPanel) for panel in Page.settings_panels)
+            any(
+                isinstance(panel, CommentPanel)
+                for panel in expand_panel_list(Page, Page.settings_panels)
+            )
         )
         form_class = Page.get_edit_handler().get_form_class()
         form = form_class()
@@ -1730,7 +1741,10 @@ class TestCommentPanel(WagtailTestUtils, TestCase):
         Test that the comment panel is present by default
         """
         self.assertTrue(
-            any(isinstance(panel, CommentPanel) for panel in Page.settings_panels)
+            any(
+                isinstance(panel, CommentPanel)
+                for panel in expand_panel_list(Page, Page.settings_panels)
+            )
         )
         form_class = Page.get_edit_handler().get_form_class()
         form = form_class()
@@ -2017,7 +2031,10 @@ class TestPublishingPanel(WagtailTestUtils, TestCase):
         Test that the publishing panel is present by default
         """
         self.assertTrue(
-            any(isinstance(panel, PublishingPanel) for panel in Page.settings_panels)
+            any(
+                isinstance(panel, PublishingPanel)
+                for panel in expand_panel_list(Page, Page.settings_panels)
+            )
         )
         form_class = Page.get_edit_handler().get_form_class()
         form = form_class()
@@ -2078,7 +2095,7 @@ class TestMultipleChooserPanelGetComparison(TestCase):
         parent_page.add_child(instance=self.page)
 
     def test_get_comparison(self):
-        # Test whether the InlinePanel passes it's label in get_comparison
+        # Test whether the MultipleChooserPanel passes its heading in get_comparison
 
         comparison = (
             self.page.get_edit_handler()

wagtail/admin/tests/test_page_chooser.py

@@ -65,12 +65,20 @@ class TestChooserBrowse(WagtailTestUtils, TestCase):
 
         checkbox_value = str(self.child_page.id)
         decoded_content = response.content.decode()
+        response_json = json.loads(decoded_content)
+        self.assertEqual(response_json["step"], "browse")
+        response_html = response_json["html"]
 
-        self.assertIn(f'value=\\"{checkbox_value}\\"', decoded_content)
+        self.assertIn(f'value="{checkbox_value}"', response_html)
 
         self.assertEqual(response.status_code, 200)
         self.assertTemplateUsed(response, "wagtailadmin/chooser/browse.html")
 
+        soup = self.get_soup(response_html)
+        search_url = soup.find("form", role="search")["action"]
+        search_query_params = parse_qs(urlsplit(search_url).query)
+        self.assertEqual(search_query_params["multiple"], ["1"])
+
     @override_settings(USE_THOUSAND_SEPARATOR=False)
     def test_multiple_chooser_view_without_thousand_separator(self):
         self.page = Page.objects.get(id=1)
@@ -241,6 +249,35 @@ class TestChooserBrowseChild(WagtailTestUtils, TestCase):
         self.assertIn(event_page.id, pages)
         self.assertTrue(pages[self.child_page.id].can_choose)
 
+    def test_with_multiple_specific_page_types_display_warning(self):
+        # Add a page that is not a SimplePage
+        event_page = EventPage(
+            title="event",
+            location="the moon",
+            audience="public",
+            cost="free",
+            date_from="2001-01-01",
+        )
+        self.root_page.add_child(instance=event_page)
+
+        # Send request
+        response = self.get({"page_type": "tests.simplepage,tests.eventpage"})
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            response.context["page_type_names"], ["Simple page", "Event page"]
+        )
+
+        html = response.json().get("html")
+        expected = """
+            <p class="help-block help-warning">
+                <svg class="icon icon-warning icon" aria-hidden="true"><use href="#icon-warning"></use></svg>
+                Only the following page types may be chosen for this field: Simple page, Event page. Search results will exclude pages of other types.
+            </p>
+        """
+
+        self.assertTagInHTML(expected, html)
+
     def test_with_unknown_page_type(self):
         response = self.get({"page_type": "foo.bar"})
         self.assertEqual(response.status_code, 404)
@@ -363,12 +400,22 @@ class TestChooserSearch(WagtailTestUtils, TransactionTestCase):
         return self.client.get(reverse("wagtailadmin_choose_page_search"), params or {})
 
     def test_simple(self):
-        response = self.get({"q": "foobarbaz"})
+        response = self.get({"q": "foobarbaz", "allow_external_link": "true"})
         self.assertEqual(response.status_code, 200)
         self.assertTemplateUsed(response, "wagtailadmin/chooser/_search_results.html")
         self.assertContains(response, "There is 1 match")
         self.assertContains(response, "foobarbaz")
 
+        # parent page link should preserve the allow_external_link parameter
+        expected_url = (
+            reverse("wagtailadmin_choose_page_child", args=[self.root_page.id])
+            + "?allow_external_link=true"
+        )
+        self.assertContains(
+            response,
+            f'<a href="{expected_url}" class="navigate-parent">{self.root_page.title}</a>',
+        )
+
     def test_partial_match(self):
         response = self.get({"q": "fooba"})
         self.assertEqual(response.status_code, 200)
@@ -912,7 +959,7 @@ class TestChooserExternalLinkWithNonRootServePath(TestChooserExternalLink):
                 "external-link-chooser-link_text": "about",
             }
         )
-        with self.assertNumQueries(11):
+        with self.assertNumQueries(10):
             response = self.post(
                 {
                     "external-link-chooser-url": f"http://localhost/{self.prefix}about/",

wagtail/admin/tests/test_privacy.py

@@ -398,11 +398,16 @@ class TestPrivacyIndicators(WagtailTestUtils, TestCase):
         # Check the response
         self.assertEqual(response.status_code, 200)
 
+        soup = self.get_soup(response.content)
+
+        public_link = soup.select_one('[data-w-zone-switch-key-value="isPublic"]')
+        private_link = soup.select_one('[data-w-zone-switch-key-value="!isPublic"]')
+
         # Check the privacy indicator is public
-        self.assertContains(
-            response, '<div class="w-hidden" data-privacy-sidebar-private>'
-        )
-        self.assertContains(response, '<div class="" data-privacy-sidebar-public>')
+        self.assertEqual(private_link["class"], ["page-status-tag", "w-hidden"])
+
+        # Check the privacy indicator is private
+        self.assertEqual(public_link["class"], ["page-status-tag"])
 
     def test_explorer_private(self):
         """
@@ -417,14 +422,14 @@ class TestPrivacyIndicators(WagtailTestUtils, TestCase):
 
         soup = self.get_soup(response.content)
 
+        public_link = soup.select_one('[data-w-zone-switch-key-value="isPublic"]')
+        private_link = soup.select_one('[data-w-zone-switch-key-value="!isPublic"]')
+
         # Check the private privacy indicator is visible
-        private_indicator = soup.select_one("[data-privacy-sidebar-private]")
-        # There should not be any classes applied
-        self.assertEqual(private_indicator["class"], [])
+        self.assertEqual(private_link["class"], ["page-status-tag"])
 
-        # Privacy indicator should be hidden
-        public_indicator = soup.select_one("[data-privacy-sidebar-public].w-hidden")
-        self.assertIsNotNone(public_indicator)
+        # Check the public privacy indicator is hidden
+        self.assertEqual(public_link["class"], ["page-status-tag", "w-hidden"])
 
     def test_explorer_private_child(self):
         """
@@ -437,11 +442,16 @@ class TestPrivacyIndicators(WagtailTestUtils, TestCase):
         # Check the response
         self.assertEqual(response.status_code, 200)
 
+        soup = self.get_soup(response.content)
+
+        public_link = soup.select_one('[data-w-zone-switch-key-value="isPublic"]')
+        private_link = soup.select_one('[data-w-zone-switch-key-value="!isPublic"]')
+
         # Check the privacy indicator is private
-        self.assertContains(response, '<div class="" data-privacy-sidebar-private>')
-        self.assertContains(
-            response, '<div class="w-hidden" data-privacy-sidebar-public>'
-        )
+        self.assertEqual(private_link["class"], ["page-status-tag"])
+
+        # Check the public privacy indicator is hidden
+        self.assertEqual(public_link["class"], ["page-status-tag", "w-hidden"])
 
     def test_explorer_list_homepage(self):
         """
@@ -491,11 +501,15 @@ class TestPrivacyIndicators(WagtailTestUtils, TestCase):
         # Check the response
         self.assertEqual(response.status_code, 200)
 
+        soup = self.get_soup(response.content)
+
+        public_link = soup.select_one('[data-w-zone-switch-key-value="isPublic"]')
+        private_link = soup.select_one('[data-w-zone-switch-key-value="!isPublic"]')
+
         # Check the privacy indicator is public
-        self.assertContains(
-            response, '<div class="w-hidden" data-privacy-sidebar-private>'
-        )
-        self.assertContains(response, '<div class="" data-privacy-sidebar-public>')
+        self.assertEqual(public_link["class"], ["page-status-tag"])
+
+        self.assertEqual(private_link["class"], ["page-status-tag", "w-hidden"])
 
     def test_edit_private(self):
         """
@@ -508,11 +522,15 @@ class TestPrivacyIndicators(WagtailTestUtils, TestCase):
         # Check the response
         self.assertEqual(response.status_code, 200)
 
+        soup = self.get_soup(response.content)
+
+        public_link = soup.select_one('[data-w-zone-switch-key-value="isPublic"]')
+        private_link = soup.select_one('[data-w-zone-switch-key-value="!isPublic"]')
+
         # Check the privacy indicator is private
-        self.assertContains(response, '<div class="" data-privacy-sidebar-private>')
-        self.assertContains(
-            response, '<div class="w-hidden" data-privacy-sidebar-public>'
-        )
+        self.assertEqual(private_link["class"], ["page-status-tag"])
+
+        self.assertEqual(public_link["class"], ["page-status-tag", "w-hidden"])
 
     def test_edit_private_child(self):
         """
@@ -526,10 +544,15 @@ class TestPrivacyIndicators(WagtailTestUtils, TestCase):
         self.assertEqual(response.status_code, 200)
 
         # Check the privacy indicator is private
-        self.assertContains(response, '<div class="" data-privacy-sidebar-private>')
-        self.assertContains(
-            response, '<div class="w-hidden" data-privacy-sidebar-public>'
-        )
+        soup = self.get_soup(response.content)
+
+        public_link = soup.select_one('[data-w-zone-switch-key-value="isPublic"]')
+        private_link = soup.select_one('[data-w-zone-switch-key-value="!isPublic"]')
+
+        # Check the privacy indicator is private
+        self.assertEqual(private_link["class"], ["page-status-tag"])
+
+        self.assertEqual(public_link["class"], ["page-status-tag", "w-hidden"])
 
     def test_private_page_options_only_password_groups(self):
         # change the private_page_options to password and login

wagtail/admin/tests/test_site_summary.py

@@ -18,9 +18,6 @@ class TestPagesSummary(WagtailTestUtils, TestCase):
         cls.wagtail_root.add_child(instance=cls.test_page)
 
         cls.test_page_group = Group.objects.create(name="Test page")
-        GroupPagePermission.objects.create(
-            group=cls.test_page_group, page=cls.test_page, permission_type="change"
-        )
 
     @classmethod
     def tearDownClass(cls):
@@ -68,14 +65,22 @@ class TestPagesSummary(WagtailTestUtils, TestCase):
         self.user.save()
         self.assertFalse(PagesSummaryItem(self.request).is_shown())
 
-    def test_user_with_limited_page_permissions_summary_links_to_their_root(self):
+    def test_user_with_limited_page_permissions(self):
+        permissions = {"add", "change", "publish", "bulk_delete", "lock", "unlock"}
         self.user.is_superuser = False
         self.user.save()
         self.user.groups.add(self.test_page_group)
-        self.assertSummaryContainsLinkToPage(self.test_page.pk)
 
-    def test_user_with_limited_page_permissions_sees_proper_page_count(self):
-        self.user.is_superuser = False
-        self.user.save()
-        self.user.groups.add(self.test_page_group)
-        self.assertSummaryContains("1 Page")
+        for permission in permissions:
+            with self.subTest(permission=permission):
+                permission_obj = GroupPagePermission.objects.create(
+                    group=self.test_page_group,
+                    page=self.test_page,
+                    permission_type=permission,
+                )
+                # Should link to the permission's page rather than Wagtail's root
+                self.assertSummaryContainsLinkToPage(self.test_page.pk)
+                # Should show the correct page count
+                self.assertSummaryContains("1 Page")
+                permission_obj.delete()
+                self.test_page_group.page_permissions.all().delete()

wagtail/admin/tests/test_templatetags.py

@@ -1,4 +1,5 @@
 import json
+import os
 import unittest
 from datetime import datetime, timedelta
 from datetime import timezone as dt_timezone
@@ -31,6 +32,24 @@ from wagtail.users.models import UserProfile
 from wagtail.utils.deprecation import RemovedInWagtail70Warning
 
 
+class TestAvatarUrlInterceptTemplateTag(WagtailTestUtils, TestCase):
+    def setUp(self):
+        self.test_user = self.create_user(
+            username="testuser",
+            email="testuser@email.com",
+            password="password",
+        )
+
+    def test_get_avatar_url_undefined(self):
+        url = avatar_url(self.test_user)
+        self.assertIn("www.gravatar.com", url)
+
+    @mock.patch.dict(os.environ, {"AVATAR_INTERCEPT": "True"}, clear=True)
+    def test_get_avatar_url_registered(self):
+        url = avatar_url(self.test_user)
+        self.assertEqual(url, "/some/avatar/fred.png")
+
+
 class TestAvatarTemplateTag(WagtailTestUtils, TestCase):
     def setUp(self):
         # Create a user