wagtail 7.1.2__py3-none-any.whl → 7.2rc1__py3-none-any.whl

wagtail/admin/tests/pages/test_create_page.py

@@ -544,6 +544,22 @@ class TestPageCreation(WagtailTestUtils, TestCase):
             post_data,
         )
 
+        soup = self.get_soup(response.content)
+        header_messages = soup.css.select(".messages[role='status'] ul > li")
+
+        # the top level message should indicate that the page could not be created
+        self.assertEqual(len(header_messages), 1)
+        message = header_messages[0]
+        self.assertIn(
+            "The page could not be created due to validation errors", message.get_text()
+        )
+
+        # the top level message should provide a go to error button
+        buttons = message.find_all("button")
+        self.assertEqual(len(buttons), 1)
+        self.assertEqual(buttons[0].attrs["data-controller"], "w-count w-focus")
+        self.assertIn("Go to the first error", buttons[0].get_text())
+
         # Check that a form error was raised
         self.assertFormError(
             response.context["form"], "title", "This field is required."
@@ -760,6 +776,22 @@ class TestPageCreation(WagtailTestUtils, TestCase):
         )
         self.assertEqual(response.status_code, 200)
 
+        soup = self.get_soup(response.content)
+        header_messages = soup.css.select(".messages[role='status'] ul > li")
+
+        # the top level message should indicate that the page could not be created
+        self.assertEqual(len(header_messages), 1)
+        message = header_messages[0]
+        self.assertIn(
+            "The page could not be created due to validation errors", message.get_text()
+        )
+
+        # the top level message should provide a go to error button
+        buttons = message.find_all("button")
+        self.assertEqual(len(buttons), 1)
+        self.assertEqual(buttons[0].attrs["data-controller"], "w-count w-focus")
+        self.assertIn("Go to the first error", buttons[0].get_text())
+
         # Check that a form error was raised
         self.assertFormError(
             response.context["form"], "date_from", "This field is required."
@@ -1144,7 +1176,7 @@ class TestPageCreation(WagtailTestUtils, TestCase):
         self.assertFormError(
             response.context["form"],
             "expire_at",
-            "Expiry date/time must be in the future",
+            "Expiry date/time must be in the future.",
         )
 
         self.assertContains(
@@ -1328,7 +1360,7 @@ class TestPageCreation(WagtailTestUtils, TestCase):
         self.assertFormError(
             response.context["form"],
             "slug",
-            "The slug 'hello-world' is already in use within the parent page",
+            "The slug 'hello-world' is already in use within the parent page.",
         )
 
         # form should be marked as having unsaved changes for the purposes of the dirty-forms warning

wagtail/admin/tests/pages/test_edit_page.py

@@ -32,6 +32,7 @@ from wagtail.test.testapp.models import (
     EVENT_AUDIENCE_CHOICES,
     Advert,
     AdvertPlacement,
+    CommentableJSONPage,
     CustomPermissionPage,
     EventCategory,
     EventPage,
@@ -883,7 +884,7 @@ class TestPageEdit(WagtailTestUtils, TestCase):
         self.assertFormError(
             response.context["form"],
             "expire_at",
-            "Expiry date/time must be in the future",
+            "Expiry date/time must be in the future.",
         )
 
         self.assertContains(
@@ -1749,7 +1750,7 @@ class TestPageEdit(WagtailTestUtils, TestCase):
         self.assertFormError(
             response.context["form"],
             "slug",
-            "The slug 'hello-world' is already in use within the parent page",
+            "The slug 'hello-world' is already in use within the parent page.",
         )
 
     def test_preview_on_edit(self):
@@ -2986,12 +2987,31 @@ class TestValidationErrorMessages(WagtailTestUtils, TestCase):
         )
         self.assertEqual(response.status_code, 200)
 
-        self.assertContains(
-            response, "The page could not be saved due to validation errors"
+        soup = self.get_soup(response.content)
+
+        header_messages = soup.css.select(".messages[role='status'] ul > li")
+
+        # the top level message should indicate that the page could not be saved
+        self.assertEqual(len(header_messages), 1)
+        message = header_messages[0]
+        self.assertIn(
+            "The page could not be saved due to validation errors", message.get_text()
         )
+
+        # the top level message should provide a go to error button
+        buttons = message.find_all("button")
+        self.assertEqual(len(buttons), 1)
+        self.assertEqual(buttons[0].attrs["data-controller"], "w-count w-focus")
+        self.assertIn("Go to the first error", buttons[0].get_text())
+
         # the error should only appear once: against the field, not in the header message
-        self.assertContains(response, "error-message", count=1)
-        self.assertContains(response, "This field is required", count=1)
+        error_messages = soup.css.select(".error-message")
+        self.assertEqual(len(error_messages), 1)
+        error_message = error_messages[0]
+        self.assertEqual(
+            error_message.parent["id"], "panel-child-content-child-title-errors"
+        )
+        self.assertIn("This field is required", error_message.get_text())
 
     def test_non_field_error(self):
         """Non-field errors should be shown in the header message"""
@@ -3070,19 +3090,43 @@ class TestValidationErrorMessages(WagtailTestUtils, TestCase):
         )
         self.assertEqual(response.status_code, 200)
 
-        self.assertContains(
-            response, "The page could not be saved due to validation errors"
+        soup = self.get_soup(response.content)
+
+        # there should be top level messages should indicate that the page could not be saved alongside other messages
+        header_messages = soup.css.select(".messages[role='status'] ul > li")
+        self.assertEqual(len(header_messages), 3)
+
+        # the first header message should indicate that the page could not be saved & contain a go to error button
+        self.assertIn(
+            "The page could not be saved due to validation errors",
+            header_messages[0].get_text(),
         )
-        self.assertContains(
-            response, "<li>The end date must be after the start date</li>", count=1
+        buttons = header_messages[0].find_all("button")
+        self.assertEqual(len(buttons), 1)
+        self.assertEqual(buttons[0].attrs["data-controller"], "w-count w-focus")
+        self.assertIn("Go to the first error", buttons[0].get_text())
+
+        # the second should be a general message about the title, no go to error button
+        self.assertIn(
+            "Title: This field is required",
+            header_messages[1].get_text(),
+        )
+        self.assertEqual(len(header_messages[1].find_all("button")), 0)
+
+        # the third header message should be the non-field error
+        self.assertIn(
+            "The end date must be after the start date",
+            header_messages[2].get_text(),
         )
 
         # Error on title shown against the title field
-        self.assertContains(response, "error-message", count=1)
-        # Error on title shown in the header message
-        self.assertContains(
-            response, "<li>Title: This field is required.</li>", count=1
+        error_messages = soup.css.select(".error-message")
+        self.assertEqual(len(error_messages), 1)
+        error_message = error_messages[0]
+        self.assertEqual(
+            error_message.parent["id"], "panel-child-content-child-title-errors"
         )
+        self.assertIn("This field is required.", error_message.get_text())
 
 
 class TestNestedInlinePanel(WagtailTestUtils, TestCase):
@@ -4107,3 +4151,73 @@ class TestCommentOutput(WagtailTestUtils, TestCase):
         comment_text = [comment["text"] for comment in comments_data["comments"]]
         comment_text.sort()
         self.assertEqual(comment_text, ["A test comment", "This is quite expensive"])
+
+    def test_comments_with_deep_contentpath_on_custom_fields(self):
+        page = CommentableJSONPage(
+            title="Commentable JSON Page",
+            slug="commentable-json-page",
+            commentable_body={
+                "header": {
+                    "title": "Comments are Welcome",
+                },
+            },
+            uncommentable_body={
+                "title": "No feedback here",
+            },
+            stream_body=[
+                {
+                    "id": "1",
+                    "type": "text",
+                    "value": "This allows comments",
+                }
+            ],
+        )
+        self.root_page.add_child(instance=page)
+
+        Comment.objects.create(
+            page=page,
+            user=self.user,
+            text="1. Comment on an existing JSON path in commentable JSONField",
+            contentpath="commentable_body.header.title",
+        )
+        Comment.objects.create(
+            page=page,
+            user=self.user,
+            text="2. Comment on a non-existing JSON path in commentable JSONField",
+            contentpath="commentable_body.header.not_valid",
+        )
+        Comment.objects.create(
+            page=page,
+            user=self.user,
+            text="3. Comment on an existing JSON path in base JSONField",
+            contentpath="uncommentable_body.title",
+        )
+        Comment.objects.create(
+            page=page,
+            user=self.user,
+            text="4. Comment on a non-existing JSON path in base JSONField",
+            contentpath="uncommentable_body.not_valid",
+        )
+        Comment.objects.create(
+            page=page,
+            user=self.user,
+            text="5. Comment on the top-level of a base JSONField",
+            contentpath="uncommentable_body",
+        )
+
+        response = self.client.get(reverse("wagtailadmin_pages:edit", args=[page.id]))
+        soup = self.get_soup(response.content)
+        comments_data_json = soup.select_one("#comments-data").string
+        comments_data = json.loads(comments_data_json)
+        comment_text = [comment["text"] for comment in comments_data["comments"]]
+        comment_text.sort()
+
+        self.assertEqual(
+            comment_text,
+            [
+                # Custom fields can define which paths are valid for comments
+                "1. Comment on an existing JSON path in commentable JSONField",
+                # Comments directly on the top-level (the field itself) are always valid
+                "5. Comment on the top-level of a base JSONField",
+            ],
+        )

wagtail/admin/tests/pages/test_explorer_view.py

@@ -180,13 +180,15 @@ class TestPageExplorer(WagtailTestUtils, TestCase):
         self.root_page.add_child(instance=event_page)
 
         orderings = {
-            "content_type": (
-                [self.new_page.id, self.old_page.id, event_page.id],
-                "-content_type",
+            "content_type__model": (
+                # SimplePage, SingleEventPage, StandardIndex
+                [self.new_page.id, event_page.id, self.old_page.id],
+                "-content_type__model",
             ),
-            "-content_type": (
-                [event_page.id, self.old_page.id, self.new_page.id],
-                "content_type",
+            "-content_type__model": (
+                # StandardIndex, SingleEventPage, SimplePage
+                [self.old_page.id, event_page.id, self.new_page.id],
+                "content_type__model",
             ),
         }
         url = reverse("wagtailadmin_explore", args=(self.root_page.id,))
@@ -345,7 +347,31 @@ class TestPageExplorer(WagtailTestUtils, TestCase):
         )
 
         # Pages must not be paginated
-        self.assertNotIsInstance(response.context["pages"], paginator.Page)
+        self.assertNotIsInstance(response.context["page_obj"], paginator.Page)
+
+    def test_reordering_disabled_when_searching_or_filtering(self):
+        standard_index_ct = ContentType.objects.get_for_model(StandardIndex).pk
+        cases = [
+            {"q": "old"},
+            {"content_type": standard_index_ct},
+            {"content_type": standard_index_ct, "q": "old"},
+        ]
+        for query in cases:
+            with self.subTest(query=query):
+                response = self.client.get(
+                    reverse("wagtailadmin_explore", args=(self.root_page.id,)),
+                    {"ordering": "ord", **query},
+                )
+                self.assertEqual(response.status_code, 200)
+                self.assertTemplateUsed(
+                    response, "wagtailadmin/pages/explorable_index.html"
+                )
+                self.assertEqual(
+                    response.context["ordering"],
+                    "-latest_revision_created_at",
+                )
+                # Pages is paginated
+                self.assertIsInstance(response.context["page_obj"], paginator.Page)
 
     def test_construct_explorer_page_queryset_hook(self):
         # testapp implements a construct_explorer_page_queryset hook
@@ -421,6 +447,7 @@ class TestPageExplorer(WagtailTestUtils, TestCase):
         self.assertTemplateUsed(response, "wagtailadmin/pages/explorable_index.html")
 
         # Check that we got the correct page
+        self.assertIsInstance(response.context["page_obj"], paginator.Page)
         self.assertEqual(response.context["page_obj"].number, 2)
         self.assertContains(response, "51-100 of 153")
 

wagtail/admin/tests/pages/test_reorder_page.py

@@ -70,6 +70,17 @@ class TestPageReorder(WagtailTestUtils, TestCase):
         child_slugs = self.index_page.get_children().values_list("slug", flat=True)
         self.assertListEqual(list(child_slugs), ["child-2", "child-3", "child-1"])
 
+    def test_page_set_page_position_non_integer_position_moves_it_to_the_end(self):
+        response = self.client.post(
+            reverse("wagtailadmin_pages:set_page_position", args=(self.child_1.id,))
+            + "?position=good"
+        )
+        self.assertEqual(response.status_code, 200)
+
+        # check if child_1 is the last child page:
+        child_slugs = self.index_page.get_children().values_list("slug", flat=True)
+        self.assertListEqual(list(child_slugs), ["child-2", "child-3", "child-1"])
+
     def test_page_move_page_position_up(self):
         """Moves child 3 to the first position."""
         response = self.client.post(

wagtail/admin/tests/test_collections_views.py

@@ -781,6 +781,18 @@ class TestSetCollectionPrivacy(CollectionInstanceTestUtils, WagtailTestUtils, Te
             params,
         )
 
+    def test_privacy_for_collection(self):
+        response = self.get(self.finance_collection.id)
+
+        # Check response
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "wagtailadmin/shared/set_privacy.html")
+        self.assertEqual(response.context["object"], self.finance_collection)
+        self.assertEqual(
+            response.context["action_url"],
+            "/admin/collections/{}/privacy/".format(self.finance_collection.id),
+        )
+
     def test_get_private_child(self):
         CollectionViewRestriction.objects.create(
             collection=self.root_collection,

wagtail/admin/tests/test_edit_handlers.py

@@ -1,7 +1,7 @@
 from collections.abc import Mapping
 from datetime import date, datetime, timezone
 from functools import wraps
-from typing import Any, Optional
+from typing import Any
 from unittest import mock
 
 from django import VERSION as DJANGO_VERSION
@@ -871,8 +871,8 @@ class TestFieldPanel(TestCase):
 
     def _get_form(
         self,
-        data: Optional[Mapping[str, Any]] = None,
-        fields: Optional[list[str]] = None,
+        data: Mapping[str, Any] | None = None,
+        fields: list[str] | None = None,
     ) -> WagtailAdminPageForm:
         cls = get_form_for_model(
             EventPage,

wagtail/admin/tests/test_filters.py

@@ -75,7 +75,7 @@ class TestFilteredModelChoiceField(WagtailTestUtils, TestCase):
             users = FilteredModelChoiceField(
                 queryset=User.objects.order_by(User.USERNAME_FIELD),
                 filter_field="id_group",
-                filter_accessor=lambda user: user.groups.all(),
+                filter_accessor=lambda user: user.groups.all().order_by("name"),
             )
 
         form = UserForm()
@@ -83,7 +83,7 @@ class TestFilteredModelChoiceField(WagtailTestUtils, TestCase):
         expected_html = """
             <select name="users" data-widget="filtered-select" data-filter-field="id_group" required id="id_users">
                 <option value="" selected>---------</option>
-                <option value="{david}" data-filter-value="{musicians},{actors}">{david_username}</option>
+                <option value="{david}" data-filter-value="{actors},{musicians}">{david_username}</option>
                 <option value="{kevin}" data-filter-value="{actors}">{kevin_username}</option>
                 <option value="{morten}" data-filter-value="{musicians}">{morten_username}</option>
             </select>

wagtail/admin/tests/test_keyboard_shortcuts.py

@@ -7,6 +7,7 @@ from django.urls import reverse
 
 from wagtail.admin.utils import get_keyboard_key_labels_from_request
 from wagtail.test.utils import WagtailTestUtils
+from wagtail.users.models import UserProfile
 
 
 class TestGetKeyboardKeyLabelsFromRequestUtil(TestCase):
@@ -65,7 +66,8 @@ class TestGetKeyboardKeyLabelsFromRequestUtil(TestCase):
 
 class TestKeyboardShortcutsDialog(WagtailTestUtils, TestCase):
     def setUp(self):
-        self.login()
+        self.test_user = self.create_test_user()
+        self.login(user=self.test_user)
 
     def test_keyboard_shortcuts_trigger_in_sidebar(self):
         response = self.client.get(reverse("wagtailadmin_home"))
@@ -83,7 +85,8 @@ class TestKeyboardShortcutsDialog(WagtailTestUtils, TestCase):
                     "role": "button",
                     "data-a11y-dialog-show": "keyboard-shortcuts-dialog",
                     "data-action": "w-action#noop:prevent:stop",
-                    "data-controller": "w-action",
+                    "data-controller": "w-kbd w-action",
+                    "data-w-kbd-key-value": "?",
                 }
             ),
             sidebar_data,
@@ -151,6 +154,53 @@ class TestKeyboardShortcutsDialog(WagtailTestUtils, TestCase):
         self.assertNotIn("comments", shortcuts_dialog.prettify())
         self.assertNotIn("Ctrl + Alt + m", all_shortcuts_text)
 
+    def test_account_link_in_modal(self):
+        """
+        Test that the 'account' link fragment is correctly rendered in the
+        keyboard shortcuts modal.
+        """
+        response = self.client.get(reverse("wagtailadmin_home"))
+        self.assertEqual(response.status_code, 200)
+
+        soup = self.get_soup(response.content)
+        shortcuts_dialog = soup.select_one("#keyboard-shortcuts-dialog")
+        self.assertIsNotNone(shortcuts_dialog)
+
+        account_link = shortcuts_dialog.select_one("a[href$='account/']")
+        self.assertIsNotNone(account_link)
+        self.assertEqual(account_link.text.strip(), "account")
+        self.assertIn("w-underline", account_link.get("class", []))
+
+    def test_modal_shows_disabled_info_when_keyboard_shortcuts_disabled(self):
+        """
+        Modal should open and show warning if keyboard shortcuts are disabled.
+        """
+        profile = UserProfile.get_for_user(self.test_user)
+        profile.keyboard_shortcuts = False
+        profile.save()
+
+        response = self.client.get(reverse("wagtailadmin_home"))
+
+        soup = self.get_soup(response.content)
+        shortcuts_dialog = soup.select_one("#keyboard-shortcuts-dialog")
+        self.assertIn(
+            "Keyboard shortcuts are currently disabled", shortcuts_dialog.prettify()
+        )
+
+    def test_modal_shows_enabled_info_when_shortcuts_enabled(self):
+        """
+        Modal should show normal info when keyboard shortcuts are enabled.
+        """
+        profile = UserProfile.get_for_user(self.test_user)
+        response = self.client.get(reverse("wagtailadmin_home"))
+        soup = self.get_soup(response.content)
+        shortcuts_dialog = soup.select_one("#keyboard-shortcuts-dialog")
+
+        self.assertTrue(profile.keyboard_shortcuts)
+        self.assertIn(
+            "Keyboard shortcuts are currently enabled", shortcuts_dialog.prettify()
+        )
+
 
 class TestMacKeyboardShortcutsDialog(WagtailTestUtils, TestCase):
     def setUp(self):

wagtail/admin/tests/test_menu.py

@@ -411,11 +411,9 @@ class TestMenuRendering(WagtailTestUtils, TestCase):
             "important-pages-generic-setting",
             "redirects",
             "important-pages-site-setting",
-            "workflow-tasks",
             "promoted-search-results",
             "icon-generic-setting",
             "file-site-setting",
-            "workflows",
             "file-generic-setting",
         }
 

wagtail/admin/tests/test_privacy.py

@@ -69,14 +69,14 @@ class TestSetPrivacyView(WagtailTestUtils, TestCase):
         """
         This tests that a blank form is returned when a user opens the set_privacy view on a public page
         """
-        response = self.client.get(
-            reverse("wagtailadmin_pages:set_privacy", args=(self.public_page.id,))
-        )
+        url = reverse("wagtailadmin_pages:set_privacy", args=(self.public_page.id,))
+        response = self.client.get(url)
 
         # Check response
         self.assertEqual(response.status_code, 200)
-        self.assertTemplateUsed(response, "wagtailadmin/page_privacy/set_privacy.html")
-        self.assertEqual(response.context["page"].specific, self.public_page)
+        self.assertTemplateUsed(response, "wagtailadmin/shared/set_privacy.html")
+        self.assertEqual(response.context["object"].specific, self.public_page)
+        self.assertEqual(response.context["action_url"], url)
 
         # Check form attributes
         self.assertEqual(response.context["form"]["restriction_type"].value(), "none")
@@ -86,14 +86,14 @@ class TestSetPrivacyView(WagtailTestUtils, TestCase):
         This tests that the restriction type and password fields as set correctly
         when a user opens the set_privacy view on a public page
         """
-        response = self.client.get(
-            reverse("wagtailadmin_pages:set_privacy", args=(self.private_page.id,))
-        )
+        url = reverse("wagtailadmin_pages:set_privacy", args=(self.private_page.id,))
+        response = self.client.get(url)
 
         # Check response
         self.assertEqual(response.status_code, 200)
-        self.assertTemplateUsed(response, "wagtailadmin/page_privacy/set_privacy.html")
-        self.assertEqual(response.context["page"].specific, self.private_page)
+        self.assertTemplateUsed(response, "wagtailadmin/shared/set_privacy.html")
+        self.assertEqual(response.context["object"].specific, self.private_page)
+        self.assertEqual(response.context["action_url"], url)
 
         # Check form attributes
         self.assertEqual(
@@ -254,16 +254,16 @@ class TestSetPrivacyView(WagtailTestUtils, TestCase):
         """
         This tests that the restriction type and group fields as set correctly when a user opens the set_privacy view on a public page
         """
-        response = self.client.get(
-            reverse(
-                "wagtailadmin_pages:set_privacy", args=(self.private_groups_page.id,)
-            )
+        url = reverse(
+            "wagtailadmin_pages:set_privacy", args=(self.private_groups_page.id,)
         )
+        response = self.client.get(url)
 
         # Check response
         self.assertEqual(response.status_code, 200)
-        self.assertTemplateUsed(response, "wagtailadmin/page_privacy/set_privacy.html")
-        self.assertEqual(response.context["page"].specific, self.private_groups_page)
+        self.assertTemplateUsed(response, "wagtailadmin/shared/set_privacy.html")
+        self.assertEqual(response.context["object"].specific, self.private_groups_page)
+        self.assertEqual(response.context["action_url"], url)
 
         # Check form attributes
         self.assertEqual(response.context["form"]["restriction_type"].value(), "groups")