wagtail 6.1.2__py3-none-any.whl → 6.2__py3-none-any.whl

wagtail/admin/tests/test_userbar.py

@@ -208,22 +208,32 @@ class TestAccessibilityCheckerConfig(WagtailTestUtils, TestCase):
         config = self.get_config()
         self.assertIsInstance(config.get("messages"), dict)
         self.assertEqual(
-            config["messages"]["empty-heading"],
-            "Empty heading found. Use meaningful text for screen reader users.",
+            config["messages"]["empty-heading"]["error_name"],
+            "Empty heading found",
+        )
+        self.assertEqual(
+            config["messages"]["empty-heading"]["help_text"],
+            "Use meaningful text for screen reader users",
         )
 
     def test_custom_message(self):
         class CustomMessageAccessibilityItem(AccessibilityItem):
             # Override via class attribute
             axe_messages = {
-                "empty-heading": "Headings should not be empty!",
+                "empty-heading": {
+                    "error_name": "Headings should not be empty!",
+                    "help_text": "Use meaningful text!",
+                },
             }
 
             # Override via method
             def get_axe_messages(self, request):
                 return {
                     **super().get_axe_messages(request),
-                    "color-contrast-enhanced": "Increase colour contrast!",
+                    "color-contrast-enhanced": {
+                        "error_name": "Insufficient colour contrast!",
+                        "help_text": "Ensure contrast ratio of at least 4.5:1",
+                    },
                 }
 
         with hooks.register_temporarily(
@@ -234,8 +244,14 @@ class TestAccessibilityCheckerConfig(WagtailTestUtils, TestCase):
             self.assertEqual(
                 config["messages"],
                 {
-                    "empty-heading": "Headings should not be empty!",
-                    "color-contrast-enhanced": "Increase colour contrast!",
+                    "empty-heading": {
+                        "error_name": "Headings should not be empty!",
+                        "help_text": "Use meaningful text!",
+                    },
+                    "color-contrast-enhanced": {
+                        "error_name": "Insufficient colour contrast!",
+                        "help_text": "Ensure contrast ratio of at least 4.5:1",
+                    },
                 },
             )
 
@@ -341,6 +357,77 @@ class TestAccessibilityCheckerConfig(WagtailTestUtils, TestCase):
                 },
             )
 
+    def test_custom_rules_and_checks(self):
+        class CustomRulesAndChecksAccessibilityItem(AccessibilityItem):
+            # Override via class attribute
+            axe_custom_checks = [
+                {
+                    "id": "check-image-alt-text",
+                    "options": {"pattern": "\\.[a-z]{1,4}$|_"},
+                },
+            ]
+
+            # Add via method
+            def get_axe_custom_rules(self, request):
+                return super().get_axe_custom_rules(request) + [
+                    {
+                        "id": "link-text-quality",
+                        "impact": "serious",
+                        "selector": "a",
+                        "tags": ["best-practice"],
+                        "any": ["check-link-text"],
+                        "enabled": True,
+                    }
+                ]
+
+            def get_axe_custom_checks(self, request):
+                return super().get_axe_custom_checks(request) + [
+                    {
+                        "id": "check-link-text",
+                        "options": {"pattern": "learn more$"},
+                    }
+                ]
+
+        with hooks.register_temporarily(
+            "construct_wagtail_userbar",
+            self.get_hook(CustomRulesAndChecksAccessibilityItem),
+        ):
+            self.maxDiff = None
+            config = self.get_config()
+            self.assertEqual(
+                config["spec"],
+                {
+                    "rules": [
+                        {
+                            "id": "alt-text-quality",
+                            "impact": "serious",
+                            "selector": "img[alt]",
+                            "tags": ["best-practice"],
+                            "any": ["check-image-alt-text"],
+                            "enabled": True,
+                        },
+                        {
+                            "id": "link-text-quality",
+                            "impact": "serious",
+                            "selector": "a",
+                            "tags": ["best-practice"],
+                            "any": ["check-link-text"],
+                            "enabled": True,
+                        },
+                    ],
+                    "checks": [
+                        {
+                            "id": "check-image-alt-text",
+                            "options": {"pattern": "\\.[a-z]{1,4}$|_"},
+                        },
+                        {
+                            "id": "check-link-text",
+                            "options": {"pattern": "learn more$"},
+                        },
+                    ],
+                },
+            )
+
 
 class TestUserbarInPageServe(WagtailTestUtils, TestCase):
     def setUp(self):

wagtail/admin/tests/test_workflows.py

@@ -20,6 +20,7 @@ from wagtail.admin.mail import (
     WorkflowStateApprovalEmailNotifier,
     WorkflowStateRejectionEmailNotifier,
 )
+from wagtail.admin.staticfiles import versioned_static
 from wagtail.admin.utils import (
     get_admin_base_url,
     get_latest_str,
@@ -293,11 +294,13 @@ class TestWorkflowsIndexView(AdminTemplateTestUtils, WagtailTestUtils, TestCase)
 
 
 class TestWorkflowPermissions(WagtailTestUtils, TestCase):
+    url_name = "wagtailadmin_reports:workflow"
+
     def setUp(self):
         self.user = self.login()
 
     def get(self, params={}):
-        return self.client.get(reverse("wagtailadmin_reports:workflow"), params)
+        return self.client.get(reverse(self.url_name), params)
 
     def test_simple(self):
         response = self.get()
@@ -340,6 +343,10 @@ class TestWorkflowPermissions(WagtailTestUtils, TestCase):
         self.assertEqual(response.status_code, 200)
 
 
+class TestWorkflowTaskPermissions(TestWorkflowPermissions):
+    url_name = "wagtailadmin_reports:workflow_tasks"
+
+
 class TestWorkflowsCreateView(AdminTemplateTestUtils, WagtailTestUtils, TestCase):
     def setUp(self):
         delete_existing_workflows()
@@ -1493,7 +1500,7 @@ class TestEditTaskView(AdminTemplateTestUtils, WagtailTestUtils, TestCase):
         self.assertEqual(moderator_url_finder.get_edit_url(self.task), expected_url)
 
 
-class BasePageWorkflowTests(WagtailTestUtils, TestCase):
+class BasePageWorkflowTests(AdminTemplateTestUtils, WagtailTestUtils, TestCase):
     model_name = "page"
 
     def setUp(self):
@@ -2502,11 +2509,53 @@ class TestApproveRejectPageWorkflow(BasePageWorkflowTests):
     def test_workflow_dashboard_panel(self):
         response = self.client.get(reverse("wagtailadmin_home"))
         self.assertContains(response, "Awaiting your review")
-        # check that ActivateWorkflowActionsForDashboard is present and passes a valid csrf token
-        self.assertRegex(
-            response.content.decode("utf-8"),
-            r"ActivateWorkflowActionsForDashboard\(\'\w+\'\)",
+        soup = self.get_soup(response.content)
+        # check that the workflow-action script is present with the correct data-activate attribute
+        workflow_action_js = versioned_static("wagtailadmin/js/workflow-action.js")
+        scripts = soup.select(f"script[src='{workflow_action_js}']")
+        self.assertEqual(len(scripts), 1)
+        script = scripts[0]
+        self.assertIsNotNone(script)
+        self.assertEqual(script.get("data-activate"), "dashboard")
+        # Should no longer contain inline JS for activating the workflow actions
+        self.assertNotContains(response, "ActivateWorkflowActionsForDashboard")
+
+    def test_workflow_action_script_included(self):
+        response = self.client.get(self.get_url("edit"))
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        # check that the workflow-action script is present with the correct
+        # data-activate and data-confirm-cancellation-url attributes
+        workflow_action_js = versioned_static("wagtailadmin/js/workflow-action.js")
+        scripts = soup.select(f"script[src='{workflow_action_js}']")
+        self.assertEqual(len(scripts), 1)
+        script = scripts[0]
+        self.assertIsNotNone(script)
+        self.assertEqual(script.get("data-activate"), "editor")
+        self.assertEqual(
+            script.get("data-confirm-cancellation-url"),
+            self.get_url("confirm_workflow_cancellation"),
         )
+        # Should no longer contain inline JS for activating the workflow actions
+        self.assertNotContains(response, "ActivateWorkflowActionsForEditView")
+
+    @override_settings(WAGTAIL_WORKFLOW_CANCEL_ON_PUBLISH=False)
+    def test_workflow_action_script_included_without_cancel_confirmation(self):
+        response = self.client.get(self.get_url("edit"))
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        # check that the workflow-action script is present with the correct data-activate attribute
+        workflow_action_js = versioned_static("wagtailadmin/js/workflow-action.js")
+        scripts = soup.select(f"script[src='{workflow_action_js}']")
+        self.assertEqual(len(scripts), 1)
+        script = scripts[0]
+        self.assertIsNotNone(script)
+        self.assertEqual(script.get("data-activate"), "editor")
+        # data-confirm-cancellation-url attribute should not be present as
+        # WAGTAIL_WORKFLOW_CANCEL_ON_PUBLISH is set to False
+        self.assertIsNone(script.get("data-confirm-cancellation-url"))
+        # Should no longer contain inline JS for activating the workflow actions
+        self.assertNotContains(response, "ActivateWorkflowActionsForEditView")
 
     def test_workflow_action_get(self):
         """
@@ -2892,6 +2941,11 @@ class TestApproveRejectSnippetWorkflowNotLockable(TestApproveRejectSnippetWorkfl
 @freeze_time("2020-03-31 12:00:00")
 class TestPageWorkflowReport(BasePageWorkflowTests):
     export_formats = ["xlsx", "csv"]
+    workflow_url_name = "wagtailadmin_reports:workflow"
+    workflow_tasks_url_name = "wagtailadmin_reports:workflow_tasks"
+    header_buttons_parent_selector = "#w-slim-header-buttons"
+    drilldown_selector = ".w-drilldown"
+    extra_params = ""
 
     def setUp(self):
         super().setUp()
@@ -2901,6 +2955,15 @@ class TestPageWorkflowReport(BasePageWorkflowTests):
         self.post("submit", follow=True)
         self.login(user=self.moderator)
 
+    def assertBreadcrumbs(self, breadcrumbs, html):
+        self.assertBreadcrumbsItemsRendered(breadcrumbs, html)
+
+    def assertPageTitle(self, soup, title):
+        self.assertEqual(soup.select_one("title").text.strip(), title)
+
+    def get(self, url, params=None):
+        return self.client.get(url, params)
+
     def setup_workflow_and_tasks(self):
         self.workflow = Workflow.objects.create(name="test_workflow")
         self.task_1 = GroupApprovalTask.objects.create(name="test_task_1")
@@ -2921,46 +2984,136 @@ class TestPageWorkflowReport(BasePageWorkflowTests):
         return response.getvalue().decode()
 
     def test_workflow_report(self):
-        response = self.client.get(reverse("wagtailadmin_reports:workflow"))
+        response = self.get(reverse(self.workflow_url_name))
         self.assertEqual(response.status_code, 200)
         self.assertContains(response, "Hello world!")
         self.assertContains(response, "test_workflow")
         self.assertContains(response, "Sebastian Mitter")
         self.assertContains(response, "March 31, 2020")
+        self.assertBreadcrumbs(
+            [{"url": "", "label": "Workflows"}],
+            response.content,
+        )
+        soup = self.get_soup(response.content)
+        by_task_link = soup.select_one(
+            f"{self.header_buttons_parent_selector} .w-header-button"
+        )
+        self.assertIsNotNone(by_task_link)
+        self.assertEqual(
+            by_task_link.get("href"),
+            reverse("wagtailadmin_reports:workflow_tasks"),
+        )
+        self.assertEqual(list(by_task_link.children)[-1].strip(), "By task")
+        self.assertIsNone(soup.select_one(".w-active-filters"))
+        self.assertPageTitle(soup, "Workflows - Wagtail")
 
-        response = self.client.get(reverse("wagtailadmin_reports:workflow_tasks"))
+        response = self.get(reverse(self.workflow_tasks_url_name))
         self.assertEqual(response.status_code, 200)
         self.assertContains(response, "Hello world!")
+        self.assertBreadcrumbs(
+            [{"url": "", "label": "Workflow tasks"}],
+            response.content,
+        )
+        soup = self.get_soup(response.content)
+        by_task_link = soup.select_one(
+            f"{self.header_buttons_parent_selector} .w-header-button"
+        )
+        self.assertIsNotNone(by_task_link)
+        self.assertEqual(
+            by_task_link.get("href"),
+            reverse("wagtailadmin_reports:workflow"),
+        )
+        self.assertEqual(list(by_task_link.children)[-1].strip(), "By workflow")
+        self.assertIsNone(soup.select_one(".w-active-filters"))
+        self.assertPageTitle(soup, "Workflow tasks - Wagtail")
 
     def test_workflow_report_filtered(self):
         # the moderator can review the task, so the workflow state should show up even when reports are filtered by reviewable
-        response = self.client.get(
-            reverse("wagtailadmin_reports:workflow"), {"reviewable": "true"}
-        )
+        response = self.get(reverse(self.workflow_url_name), {"reviewable": "true"})
         self.assertEqual(response.status_code, 200)
         self.assertContains(response, "Hello world!")
         self.assertContains(response, "test_workflow")
         self.assertContains(response, "Sebastian Mitter")
         self.assertContains(response, "March 31, 2020")
 
-        response = self.client.get(
-            reverse("wagtailadmin_reports:workflow_tasks"), {"reviewable": "true"}
+        # Should render the export buttons inside the header "more" dropdown
+        # with the filtered URL
+        soup = self.get_soup(response.content)
+        links = soup.select(f"{self.header_buttons_parent_selector} .w-dropdown a")
+        unfiltered_url = reverse(self.workflow_url_name)
+        filtered_url = f"{unfiltered_url}?reviewable=true{self.extra_params}"
+        self.assertEqual(len(links), 2)
+        self.assertEqual(
+            [link.get("href") for link in links],
+            [f"{filtered_url}&export=xlsx", f"{filtered_url}&export=csv"],
+        )
+
+        # Should render the active filter pill
+        active_filter = soup.select_one(".w-active-filters .w-pill__content")
+        clear_button = soup.select_one(".w-active-filters .w-pill__remove")
+        self.assertIsNotNone(active_filter)
+        self.assertIsNotNone(clear_button)
+        self.assertNotIn("reviewable", clear_button.attrs.get("data-w-swap-src-value"))
+        self.assertEqual(clear_button.attrs.get("data-w-swap-reflect-value"), "true")
+
+        # Should render the filter inside the drilldown component
+        inputs = soup.select(
+            f"{self.drilldown_selector} input[name='reviewable'][type='radio']"
+        )
+        self.assertEqual(len(inputs), 2)
+        self.assertEqual(inputs[0].get("value"), "")
+        self.assertIsNone(inputs[0].get("checked"))
+        self.assertEqual(inputs[1].get("value"), "true")
+        self.assertEqual(inputs[1].get("checked"), "")
+
+        response = self.get(
+            reverse(self.workflow_tasks_url_name),
+            {"reviewable": "true"},
         )
         self.assertEqual(response.status_code, 200)
         self.assertContains(response, "Hello world!")
 
+        # Should render the export buttons inside the header "more" dropdown
+        # with the filtered URL
+        soup = self.get_soup(response.content)
+        links = soup.select(f"{self.header_buttons_parent_selector} .w-dropdown a")
+        unfiltered_url = reverse(self.workflow_tasks_url_name)
+        filtered_url = f"{unfiltered_url}?reviewable=true{self.extra_params}"
+        self.assertEqual(len(links), 2)
+        self.assertEqual(
+            [link.get("href") for link in links],
+            [f"{filtered_url}&export=xlsx", f"{filtered_url}&export=csv"],
+        )
+
+        # Should render the active filter pill
+        active_filter = soup.select_one(".w-active-filters .w-pill__content")
+        clear_button = soup.select_one(".w-active-filters .w-pill__remove")
+        self.assertIsNotNone(active_filter)
+        self.assertIsNotNone(clear_button)
+        self.assertNotIn("reviewable", clear_button.attrs.get("data-w-swap-src-value"))
+        self.assertEqual(clear_button.attrs.get("data-w-swap-reflect-value"), "true")
+
+        # Should render the filter inside the drilldown component
+        inputs = soup.select(
+            f"{self.drilldown_selector} input[name='reviewable'][type='radio']"
+        )
+        self.assertEqual(len(inputs), 2)
+        self.assertEqual(inputs[0].get("value"), "")
+        self.assertIsNone(inputs[0].get("checked"))
+        self.assertEqual(inputs[1].get("value"), "true")
+        self.assertEqual(inputs[1].get("checked"), "")
+
         # the submitter cannot review the task, so the workflow state shouldn't show up when reports are filtered by reviewable
         self.login(self.submitter)
-        response = self.client.get(
-            reverse("wagtailadmin_reports:workflow"), {"reviewable": "true"}
-        )
+        response = self.get(reverse(self.workflow_url_name), {"reviewable": "true"})
         self.assertEqual(response.status_code, 200)
         self.assertNotContains(response, "Hello world!")
         self.assertNotContains(response, "Sebastian Mitter")
         self.assertNotContains(response, "March 31, 2020")
 
-        response = self.client.get(
-            reverse("wagtailadmin_reports:workflow_tasks"), {"reviewable": "true"}
+        response = self.get(
+            reverse(self.workflow_tasks_url_name),
+            {"reviewable": "true"},
         )
         self.assertEqual(response.status_code, 200)
         self.assertNotContains(response, "Hello world!")
@@ -2968,8 +3121,8 @@ class TestPageWorkflowReport(BasePageWorkflowTests):
     def test_workflow_report_export(self):
         for export_format in self.export_formats:
             with self.subTest(export_format=export_format):
-                response = self.client.get(
-                    reverse("wagtailadmin_reports:workflow"),
+                response = self.get(
+                    reverse(self.workflow_url_name),
                     {"export": export_format},
                 )
                 content = self.get_file_content(response, export_format)
@@ -2979,8 +3132,8 @@ class TestPageWorkflowReport(BasePageWorkflowTests):
                 self.assertIn("submitter", content)
                 self.assertIn("2020-03-31", content)
 
-                response = self.client.get(
-                    reverse("wagtailadmin_reports:workflow_tasks"),
+                response = self.get(
+                    reverse(self.workflow_tasks_url_name),
                     {"export": export_format},
                 )
                 content = self.get_file_content(response, export_format)
@@ -2992,8 +3145,8 @@ class TestPageWorkflowReport(BasePageWorkflowTests):
             with self.subTest(export_format=export_format):
                 # the moderator can review the task, so the workflow state should show up even when reports are filtered by reviewable
                 self.login(self.moderator)
-                response = self.client.get(
-                    reverse("wagtailadmin_reports:workflow"),
+                response = self.get(
+                    reverse(self.workflow_url_name),
                     {"reviewable": "true", "export": export_format},
                 )
                 content = self.get_file_content(response, export_format)
@@ -3003,8 +3156,8 @@ class TestPageWorkflowReport(BasePageWorkflowTests):
                 self.assertIn("submitter", content)
                 self.assertIn("2020-03-31", content)
 
-                response = self.client.get(
-                    reverse("wagtailadmin_reports:workflow_tasks"),
+                response = self.get(
+                    reverse(self.workflow_tasks_url_name),
                     {"reviewable": "true", "export": export_format},
                 )
                 content = self.get_file_content(response, export_format)
@@ -3013,8 +3166,8 @@ class TestPageWorkflowReport(BasePageWorkflowTests):
 
                 # the submitter cannot review the task, so the workflow state shouldn't show up when reports are filtered by reviewable
                 self.login(self.submitter)
-                response = self.client.get(
-                    reverse("wagtailadmin_reports:workflow"),
+                response = self.get(
+                    reverse(self.workflow_url_name),
                     {"reviewable": "true", "export": export_format},
                 )
                 content = self.get_file_content(response, export_format)
@@ -3023,8 +3176,8 @@ class TestPageWorkflowReport(BasePageWorkflowTests):
                 self.assertNotIn("submitter", content)
                 self.assertNotIn("2020-03-31", content)
 
-                response = self.client.get(
-                    reverse("wagtailadmin_reports:workflow_tasks"),
+                response = self.get(
+                    reverse(self.workflow_tasks_url_name),
                     {"reviewable": "true", "export": export_format},
                 )
                 content = self.get_file_content(response, export_format)
@@ -3033,7 +3186,7 @@ class TestPageWorkflowReport(BasePageWorkflowTests):
 
     def test_workflow_report_deleted(self):
         self.object.delete()
-        response = self.client.get(reverse("wagtailadmin_reports:workflow"))
+        response = self.get(reverse(self.workflow_url_name))
         self.assertEqual(response.status_code, 200)
         self.assertNotContains(response, "Hello world!")
         # test_workflow is only rendered in the filter, not the results
@@ -3041,15 +3194,46 @@ class TestPageWorkflowReport(BasePageWorkflowTests):
         self.assertNotContains(response, "Sebastian Mitter")
         self.assertNotContains(response, "March 31, 2020")
 
-        response = self.client.get(reverse("wagtailadmin_reports:workflow_tasks"))
+        response = self.get(reverse(self.workflow_tasks_url_name))
         self.assertEqual(response.status_code, 200)
         self.assertNotContains(response, "Hello world!")
 
 
+class TestPageWorkflowReportResults(TestPageWorkflowReport):
+    workflow_url_name = "wagtailadmin_reports:workflow_results"
+    workflow_tasks_url_name = "wagtailadmin_reports:workflow_tasks_results"
+    header_buttons_parent_selector = (
+        '[data-controller="w-teleport"]'
+        '[data-w-teleport-target-value="#w-slim-header-buttons"]'
+    )
+    drilldown_selector = (
+        '[data-controller="w-teleport"]'
+        '[data-w-teleport-target-value="#filters-drilldown"]'
+    )
+    extra_params = "&_w_filter_fragment=true"
+
+    def assertBreadcrumbs(self, breadcrumbs, html):
+        self.assertBreadcrumbsNotRendered(html)
+
+    def assertPageTitle(self, soup, title):
+        self.assertIsNone(soup.select_one("title"))
+
+    def get(self, url, params=None):
+        params = params or {}
+        params["_w_filter_fragment"] = "true"
+        return super().get(url, params)
+
+
 class TestSnippetWorkflowReport(TestPageWorkflowReport, BaseSnippetWorkflowTests):
     pass
 
 
+class TestSnippetWorkflowReportResults(
+    TestPageWorkflowReportResults, BaseSnippetWorkflowTests
+):
+    pass
+
+
 class TestNonLockableSnippetWorkflowReport(
     TestPageWorkflowReport, BaseSnippetWorkflowTests
 ):
@@ -3060,6 +3244,12 @@ class TestNonLockableSnippetWorkflowReport(
     model = ModeratedModel
 
 
+class TestNonLockableSnippetWorkflowReportResults(
+    TestPageWorkflowReportResults, BaseSnippetWorkflowTests
+):
+    model = ModeratedModel
+
+
 class TestPageNotificationPreferences(BasePageWorkflowTests):
     def setUp(self):
         super().setUp()
@@ -3325,7 +3515,7 @@ class TestSnippetNotificationPreferencesHTML(TestSnippetNotificationPreferences)
     pass
 
 
-class TestDisableViews(AdminTemplateTestUtils, BasePageWorkflowTests):
+class TestDisableViews(BasePageWorkflowTests):
     def test_disable_workflow(self):
         """Test that deactivating a workflow sets it to inactive and cancels in progress states"""
         self.login(self.submitter)