wagtail 7.0.2__py3-none-any.whl → 7.1__py3-none-any.whl

wagtail/admin/tests/test_userbar.py

@@ -1,5 +1,6 @@
 import json
 
+from django.conf import settings
 from django.contrib.auth.models import AnonymousUser, Permission
 from django.template import Context, Template
 from django.test import TestCase, override_settings
@@ -8,7 +9,8 @@ from django.utils import translation
 from django.utils.translation import gettext
 
 from wagtail import hooks
-from wagtail.admin.userbar import AccessibilityItem
+from wagtail.admin.templatetags.wagtailadmin_tags import absolute_static
+from wagtail.admin.userbar import AccessibilityItem, Userbar
 from wagtail.coreutils import get_dummy_request
 from wagtail.models import PAGE_TEMPLATE_VAR, Locale, Page, Site
 from wagtail.test.context_processors import get_call_count, reset_call_count
@@ -24,6 +26,7 @@ class TestUserbarTag(WagtailTestUtils, TestCase):
             username="test", email="test@email.com", password="password"
         )
         self.homepage = Page.objects.get(id=2)
+        self.parent_page = self.homepage.get_parent()
 
     def dummy_request(
         self,
@@ -51,10 +54,36 @@ class TestUserbarTag(WagtailTestUtils, TestCase):
                 "request": self.dummy_request(self.user),
             }
         )
-        with self.assertNumQueries(5):
+        with self.assertNumQueries(4):
             content = template.render(context)
 
         self.assertIn("<!-- Wagtail user bar embed code -->", content)
+        soup = self.get_soup(content)
+
+        css_links = soup.select("link[rel='stylesheet']")
+        self.assertEqual(
+            [link.get("href") for link in css_links],
+            [
+                # Wagtail admin core CSS should be linked with absolute URL to
+                # ensure it works when loaded from a different domain
+                # (e.g. headless frontend)
+                absolute_static("wagtailadmin/css/core.css"),
+                # Custom CSS must be changed appropriately if necessary
+                "/path/to/my/custom.css",
+            ],
+        )
+
+        scripts = soup.select("script[src]")
+        self.assertEqual(
+            [script.get("src") for script in scripts],
+            [
+                # Wagtail vendor and userbar JS should be linked with absolute
+                # URL to ensure it works when loaded from a different domain
+                # (e.g. headless frontend)
+                absolute_static("wagtailadmin/js/vendor.js"),
+                absolute_static("wagtailadmin/js/userbar.js"),
+            ],
+        )
 
     def test_userbar_does_not_break_without_request(self):
         template = Template("{% load wagtailuserbar %}{% wagtailuserbar %}boom")
@@ -104,7 +133,16 @@ class TestUserbarTag(WagtailTestUtils, TestCase):
 
         self.assertIn("<!-- Wagtail user bar embed code -->", content)
 
-    def test_edit_link(self):
+        # Should render the "Go to Wagtail admin" link using an absolute URL
+        soup = self.get_soup(content)
+        admin_url = reverse("wagtailadmin_home")
+        admin_link = soup.select_one(
+            f"a[href='{settings.WAGTAILADMIN_BASE_URL}{admin_url}']"
+        )
+        self.assertIsNotNone(admin_link)
+        self.assertEqual(admin_link.text.strip(), "Go to Wagtail admin")
+
+    def test_edit_and_explore_links(self):
         template = Template("{% load wagtailuserbar %}{% wagtailuserbar %}")
         content = template.render(
             Context(
@@ -115,9 +153,23 @@ class TestUserbarTag(WagtailTestUtils, TestCase):
             )
         )
         self.assertIn("<!-- Wagtail user bar embed code -->", content)
-        self.assertIn("Edit this page", content)
+        soup = self.get_soup(content)
+
+        edit_url = reverse("wagtailadmin_pages:edit", args=(self.homepage.id,))
+        edit_link = soup.select_one(
+            f"a[href='{settings.WAGTAILADMIN_BASE_URL}{edit_url}']"
+        )
+        self.assertIsNotNone(edit_link)
+        self.assertEqual(edit_link.text.strip(), "Edit this page")
 
-    def test_userbar_edit_menu_in_previews(self):
+        explore_url = reverse("wagtailadmin_explore", args=(self.parent_page.id,))
+        explore_link = soup.select_one(
+            f"a[href='{settings.WAGTAILADMIN_BASE_URL}{explore_url}']"
+        )
+        self.assertIsNotNone(explore_link)
+        self.assertEqual(explore_link.text.strip(), "Show in Explorer")
+
+    def test_userbar_edit_and_explore_menu_in_previews(self):
         # The edit link should be visible on draft, revision, and workflow previews.
         # https://github.com/wagtail/wagtail/issues/10002
         template = Template("{% load wagtailuserbar %}{% wagtailuserbar %}")
@@ -130,10 +182,21 @@ class TestUserbarTag(WagtailTestUtils, TestCase):
             )
         )
         self.assertIn("<!-- Wagtail user bar embed code -->", content)
-        self.assertIn("Edit this page", content)
-        self.assertIn(
-            reverse("wagtailadmin_pages:edit", args=(self.homepage.id,)), content
+        soup = self.get_soup(content)
+
+        edit_url = reverse("wagtailadmin_pages:edit", args=(self.homepage.id,))
+        edit_link = soup.select_one(
+            f"a[href='{settings.WAGTAILADMIN_BASE_URL}{edit_url}']"
+        )
+        self.assertIsNotNone(edit_link)
+        self.assertEqual(edit_link.text.strip(), "Edit this page")
+
+        explore_url = reverse("wagtailadmin_explore", args=(self.parent_page.id,))
+        explore_link = soup.select_one(
+            f"a[href='{settings.WAGTAILADMIN_BASE_URL}{explore_url}']"
         )
+        self.assertIsNotNone(explore_link)
+        self.assertEqual(explore_link.text.strip(), "Show in Explorer")
 
     def test_userbar_edit_menu_not_in_preview(self):
         # The edit link should not be visible on PreviewOnEdit/Create views.
@@ -155,6 +218,15 @@ class TestUserbarTag(WagtailTestUtils, TestCase):
             reverse("wagtailadmin_pages:edit", args=(self.homepage.id,)), content
         )
 
+        # The explore link should still be visible
+        soup = self.get_soup(content)
+        explore_url = reverse("wagtailadmin_explore", args=(self.parent_page.id,))
+        explore_link = soup.select_one(
+            f"a[href='{settings.WAGTAILADMIN_BASE_URL}{explore_url}']"
+        )
+        self.assertIsNotNone(explore_link)
+        self.assertEqual(explore_link.text.strip(), "Show in Explorer")
+
     def test_userbar_hidden_in_preview_panel(self):
         template = Template("{% load wagtailuserbar %}{% wagtailuserbar %}")
         content = template.render(
@@ -177,11 +249,15 @@ class TestAccessibilityCheckerConfig(WagtailTestUtils, TestCase):
         self.request = get_dummy_request()
         self.request.user = self.user
 
-    def get_script(self):
-        template = Template("{% load wagtailuserbar %}{% wagtailuserbar %}")
+    def get_content(self, position="bottom-right"):
+        template = Template(
+            f"{{% load wagtailuserbar %}}{{% wagtailuserbar position='{position}' %}}"
+        )
         content = template.render(Context({"request": self.request}))
-        soup = self.get_soup(content)
+        return self.get_soup(content)
 
+    def get_script(self):
+        soup = self.get_content()
         # Should include the configuration as a JSON script with the specific id
         return soup.find("script", id="accessibility-axe-configuration")
 
@@ -197,6 +273,25 @@ class TestAccessibilityCheckerConfig(WagtailTestUtils, TestCase):
 
         return customise_accessibility_checker
 
+    def test_position(self):
+        content = self.get_content(position="top-left")
+        # The element with the data-wagtail-userbar attribute should have the
+        # right CSS class (w-userbar--top-left) for the positioning
+        target = content.select_one("aside [data-wagtail-userbar]")
+        self.assertIsNotNone(target)
+        self.assertIn("w-userbar--top-left", target.get("class"))
+
+        # The accessibility results dialog should be teleported to the
+        # [data-wagtail-userbar] element so that it is positioned correctly
+        dialog_content = content.select_one("#accessibility-results")
+        self.assertIsNotNone(dialog_content)
+        template = dialog_content.parent
+        self.assertIsNotNone(template)
+        self.assertEqual(
+            template.get("data-w-teleport-target-value"),
+            "[data-wagtail-userbar]",
+        )
+
     def test_config_json(self):
         script = self.get_script()
         # The configuration should be a valid non-empty JSON script
@@ -302,7 +397,7 @@ class TestAccessibilityCheckerConfig(WagtailTestUtils, TestCase):
                         # Override via class attribute
                         ".sr-only",
                         # Should include the default exclude selectors
-                        {"fromShadowDOM": ["wagtail-userbar"]},
+                        {"fromShadowDom": ["wagtail-userbar"]},
                         # Override via method
                         "[data-please-ignore]",
                     ],
@@ -623,8 +718,8 @@ class TestUserbarAddLink(WagtailTestUtils, TestCase):
         self.assertEqual(response.status_code, 200)
 
         # page allows subpages, so the 'add page' button should show
-        expected_url = reverse(
-            "wagtailadmin_pages:add_subpage", args=(self.event_index.id,)
+        expected_url = settings.WAGTAILADMIN_BASE_URL + (
+            reverse("wagtailadmin_pages:add_subpage", args=(self.event_index.id,))
         )
         needle = f"""
             <a href="{expected_url}" target="_parent" role="menuitem">
@@ -648,3 +743,143 @@ class TestUserbarAddLink(WagtailTestUtils, TestCase):
         soup = self.get_soup(response.content)
         link = soup.find("a", attrs={"href": expected_url})
         self.assertIsNone(link)
+
+
+class TestUserbarComponent(WagtailTestUtils, TestCase):
+    def setUp(self):
+        self.request = get_dummy_request()
+        self.request.user = self.create_superuser(
+            username="test", email="test@email.com", password="password"
+        )
+        self.homepage = Page.objects.get(id=2)
+        self.parent_page = self.homepage.get_parent()
+
+    def test_render_anonymous_user(self):
+        self.request.user = AnonymousUser()
+        rendered = Userbar().render_html({"request": self.request})
+        soup = self.get_soup(rendered)
+
+        items = soup.select("li")
+        self.assertEqual(len(items), 2)
+
+        admin_url = f"{settings.WAGTAILADMIN_BASE_URL}{reverse('wagtailadmin_home')}"
+        admin_item = items[0]
+        admin_link = admin_item.select_one("a")
+        self.assertIsNotNone(admin_link)
+        self.assertEqual(admin_link.get("href"), admin_url)
+        self.assertEqual(admin_link.text.strip(), "Go to Wagtail admin")
+
+        accessibility_item = items[-1]
+        button = accessibility_item.select_one("button")
+        self.assertIsNotNone(button)
+        self.assertEqual(
+            button.get_text(separator=" | ", strip=True).strip(),
+            "Issues found | Accessibility",
+        )
+
+    def test_render_no_request(self):
+        rendered = Userbar().render_html({})
+        soup = self.get_soup(rendered)
+
+        items = soup.select("li")
+        self.assertEqual(len(items), 2)
+
+        admin_url = f"{settings.WAGTAILADMIN_BASE_URL}{reverse('wagtailadmin_home')}"
+        admin_item = items[0]
+        admin_link = admin_item.select_one("a")
+        self.assertIsNotNone(admin_link)
+        self.assertEqual(admin_link.get("href"), admin_url)
+        self.assertEqual(admin_link.text.strip(), "Go to Wagtail admin")
+
+        accessibility_item = items[-1]
+        button = accessibility_item.select_one("button")
+        self.assertIsNotNone(button)
+        self.assertEqual(
+            button.get_text(separator=" | ", strip=True).strip(),
+            "Issues found | Accessibility",
+        )
+
+    def test_render_minimal(self):
+        rendered = Userbar().render_html({"request": self.request})
+        soup = self.get_soup(rendered)
+
+        userbar = soup.select_one("[data-wagtail-userbar]")
+        self.assertIsNotNone(userbar)
+        self.assertEqual(
+            userbar.get("data-wagtail-userbar-origin"),
+            settings.WAGTAILADMIN_BASE_URL,
+        )
+
+        items = soup.select("li")
+        self.assertEqual(len(items), 2)
+
+        admin_url = f"{settings.WAGTAILADMIN_BASE_URL}{reverse('wagtailadmin_home')}"
+        admin_item = items[0]
+        admin_link = admin_item.select_one("a")
+        self.assertIsNotNone(admin_link)
+        self.assertEqual(admin_link.get("href"), admin_url)
+        self.assertEqual(admin_link.text.strip(), "Go to Wagtail admin")
+
+        accessibility_item = items[-1]
+        button = accessibility_item.select_one("button")
+        self.assertIsNotNone(button)
+        self.assertEqual(
+            button.get_text(separator=" | ", strip=True).strip(),
+            "Issues found | Accessibility",
+        )
+
+    def test_render_with_page(self):
+        rendered = Userbar(object=self.homepage).render_html(
+            {"request": self.request, PAGE_TEMPLATE_VAR: self.homepage}
+        )
+        soup = self.get_soup(rendered)
+
+        links = soup.select("li a")
+        expected_urls = [
+            reverse("wagtailadmin_home"),
+            reverse("wagtailadmin_explore", args=(self.parent_page.id,)),
+            reverse("wagtailadmin_pages:edit", args=(self.homepage.id,)),
+            reverse("wagtailadmin_pages:add_subpage", args=(self.homepage.id,)),
+        ]
+        self.assertEqual(len(links), 4)
+        self.assertEqual(
+            [link.get("href") for link in links],
+            [f"{settings.WAGTAILADMIN_BASE_URL}{url}" for url in expected_urls],
+        )
+
+        accessibility_button = soup.select_one("li button")
+        self.assertIsNotNone(accessibility_button)
+        self.assertEqual(
+            accessibility_button.get_text(separator=" | ", strip=True).strip(),
+            "Issues found | Accessibility",
+        )
+
+    @override_settings(WAGTAILADMIN_BASE_URL=None)
+    def test_render_without_admin_base_url_setting(self):
+        rendered = Userbar().render_html({"request": self.request})
+        soup = self.get_soup(rendered)
+
+        userbar = soup.select_one("[data-wagtail-userbar]")
+        self.assertIsNotNone(userbar)
+        # Default to an empty string instead of rendering None,
+        # so the JS code can provide the fallback
+        self.assertEqual(userbar.get("data-wagtail-userbar-origin"), "")
+
+        items = soup.select("li")
+        self.assertEqual(len(items), 2)
+
+        # Becomes the root-relative URL since WAGTAILADMIN_BASE_URL is None
+        admin_url = reverse("wagtailadmin_home")
+        admin_item = items[0]
+        admin_link = admin_item.select_one("a")
+        self.assertIsNotNone(admin_link)
+        self.assertEqual(admin_link.get("href"), admin_url)
+        self.assertEqual(admin_link.text.strip(), "Go to Wagtail admin")
+
+        accessibility_item = items[-1]
+        button = accessibility_item.select_one("button")
+        self.assertIsNotNone(button)
+        self.assertEqual(
+            button.get_text(separator=" | ", strip=True).strip(),
+            "Issues found | Accessibility",
+        )

wagtail/admin/tests/test_widgets.py

@@ -2,6 +2,7 @@ import json
 import re
 from html import unescape
 
+from bs4 import BeautifulSoup
 from django import forms
 from django.test import TestCase
 from django.test.utils import override_settings
@@ -9,7 +10,7 @@ from django.utils.html import escape
 
 from wagtail.admin import widgets
 from wagtail.admin.forms.tags import TagField
-from wagtail.models import Page
+from wagtail.models import Locale, Page
 from wagtail.test.testapp.forms import AdminStarDateInput
 from wagtail.test.testapp.models import EventPage, RestaurantTag, SimplePage
 from wagtail.utils.deprecation import RemovedInWagtail80Warning
@@ -698,20 +699,224 @@ class TestFilteredSelect(TestCase):
 
 
 class TestSlugInput(TestCase):
+    def getAttrs(self, *args, **kwargs):
+        return (
+            BeautifulSoup(
+                widgets.SlugInput(*args, **kwargs).render("slug", None),
+                "html.parser",
+            )
+            .find("input")
+            .attrs
+        )
+
     def test_has_data_attr(self):
-        widget = widgets.slug.SlugInput()
+        widget = widgets.SlugInput()
 
         html = widget.render("test", None, attrs={"id": "test-id"})
 
         self.assertInHTML(
-            '<input type="text" name="test" data-controller="w-slug" data-action="blur-&gt;w-slug#slugify w-sync:check-&gt;w-slug#compare w-sync:apply-&gt;w-slug#urlify:prevent" data-w-slug-allow-unicode-value data-w-slug-compare-as-param="urlify" id="test-id">',
+            '<input type="text" name="test" data-controller="w-slug" data-action="blur-&gt;w-slug#slugify w-sync:check-&gt;w-slug#compare w-sync:apply-&gt;w-slug#urlify:prevent" data-w-slug-allow-unicode-value data-w-slug-compare-as-param="urlify" data-w-slug-trim-value="true" id="test-id">',
             html,
         )
 
     @override_settings(WAGTAIL_ALLOW_UNICODE_SLUGS=False)
-    def test_render_data_atrrs_from_settings(self):
-        widget = widgets.slug.SlugInput()
+    def test_render_data_attrs_from_settings(self):
+        widget = widgets.SlugInput()
 
         html = widget.render("test", None, attrs={"id": "test-id"})
 
         self.assertNotIn("data-w-slug-allow-unicode-value", html)
+
+    def test_with_locale_and_formatters_not_provided(self):
+        self.assertEqual(
+            self.getAttrs(),
+            {
+                "data-action": "blur->w-slug#slugify w-sync:check->w-slug#compare w-sync:apply->w-slug#urlify:prevent",
+                "data-controller": "w-slug",
+                "data-w-slug-allow-unicode-value": "",
+                "data-w-slug-compare-as-param": "urlify",
+                # "data-w-slug-formatters-value":... # not included at all
+                # "data-w-slug-locale-value":... # not included at all
+                "data-w-slug-trim-value": "true",
+                "name": "slug",
+                "type": "text",
+            },
+        )
+
+        self.assertEqual(
+            self.getAttrs(formatters=[], locale=None),
+            {
+                "data-action": "blur->w-slug#slugify w-sync:check->w-slug#compare w-sync:apply->w-slug#urlify:prevent",
+                "data-controller": "w-slug",
+                "data-w-slug-allow-unicode-value": "",
+                "data-w-slug-compare-as-param": "urlify",
+                # "data-w-slug-formatters-value":... # not included at all
+                # "data-w-slug-locale-value":... # not included at all
+                "data-w-slug-trim-value": "true",
+                "name": "slug",
+                "type": "text",
+            },
+        )
+
+    # Test formatters argument
+
+    def test_with_formatters_provided_are_escaped(self):
+        self.assertEqual(
+            self.getAttrs(formatters=[(r"\D\s[']+", "'?'")])[
+                "data-w-slug-formatters-value"
+            ],
+            '[[["\\\\D\\\\s[\']+","gu"],"\'?\'"]]',
+        )
+
+    def test_with_formatters_as_string(self):
+        self.assertEqual(
+            self.getAttrs(formatters=[r"\d"])["data-w-slug-formatters-value"],
+            '[[["\\\\d","gu"],""]]',
+        )
+
+        # handling of inline flags
+        self.assertEqual(
+            self.getAttrs(formatters=[r"(?m)^\d+"])["data-w-slug-formatters-value"],
+            '[[["^\\\\d+","gmu"],""]]',
+        )
+
+    def test_with_formatters_as_pattern(self):
+        self.assertEqual(
+            self.getAttrs(formatters=[re.compile(r"\d")])[
+                "data-w-slug-formatters-value"
+            ],
+            '[[["\\\\d","gu"],""]]',
+        )
+
+        # handling of inline flags
+        self.assertEqual(
+            self.getAttrs(
+                formatters=[re.compile(r"(?i)\b(?:and\|or\|the\|in\|of\|to)\b")]
+            )["data-w-slug-formatters-value"],
+            '[[["\\\\b(?:and\\\\|or\\\\|the\\\\|in\\\\|of\\\\|to)\\\\b","giu"],""]]',
+        )
+
+    def test_with_formatters_as_list_like_with_string(self):
+        self.assertEqual(
+            self.getAttrs(formatters=[["ABC"]])["data-w-slug-formatters-value"],
+            '[[["ABC","gu"],""]]',
+        )
+
+        self.assertEqual(
+            self.getAttrs(formatters=[(r"\d",)])["data-w-slug-formatters-value"],
+            '[[["\\\\d","gu"],""]]',
+        )
+
+    def test_with_formatters_as_list_like_with_pattern(self):
+        self.assertEqual(
+            self.getAttrs(formatters=[[re.compile(r"(?i)!")]])[
+                "data-w-slug-formatters-value"
+            ],
+            '[[["!","giu"],""]]',
+        )
+        self.assertEqual(
+            self.getAttrs(formatters=[(re.compile("(?m)^A"),)])[
+                "data-w-slug-formatters-value"
+            ],
+            '[[["^A","gmu"],""]]',
+        )
+
+    def test_with_formatters_with_replace(self):
+        self.assertEqual(
+            self.getAttrs(formatters=[(r"\d", "X")])["data-w-slug-formatters-value"],
+            '[[["\\\\d","gu"],"X"]]',
+        )
+
+        self.assertEqual(
+            self.getAttrs(formatters=[[re.compile(r"\d{1,3}"), "X"]])[
+                "data-w-slug-formatters-value"
+            ],
+            '[[["\\\\d{1,3}","gu"],"X"]]',
+        )
+
+    def test_with_formatters_with_replace_and_flags(self):
+        self.assertEqual(
+            self.getAttrs(
+                formatters=[
+                    [re.compile(r"^(?!blog[-\s])", flags=re.MULTILINE), "blog-", "u"]
+                ]
+            )["data-w-slug-formatters-value"],
+            '[[["^(?!blog[-\\\\s])","mu"],"blog-"]]',
+        )
+
+        self.assertEqual(
+            self.getAttrs(
+                formatters=[[re.compile(r"(?i)a*"), "Z", "g"], [r"the", "", "u"]]
+            )["data-w-slug-formatters-value"],
+            '[[["a*","gi"],"Z"],[["the","u"],""]]',
+        )
+
+    def test_with_multiple_formatters(self):
+        self.assertEqual(
+            self.getAttrs(
+                formatters=[
+                    r"\d",
+                    [r"(?<!\S)Й", "Y"],
+                    [re.compile(r"(?<!\S)Є"), "Ye", "u"],
+                    (r"(?i)the",),
+                ]
+            )["data-w-slug-formatters-value"],
+            '[[["\\\\d","gu"],""],[["(?<!\\\\S)\\u0419","gu"],"Y"],[["(?<!\\\\S)\\u0404","u"],"Ye"],[["the","giu"],""]]',
+        )
+
+    # Test locale argument
+
+    def test_with_locale_provided(self):
+        self.assertEqual(
+            self.getAttrs(locale="uk-UK"),
+            {
+                "data-action": "blur->w-slug#slugify w-sync:check->w-slug#compare w-sync:apply->w-slug#urlify:prevent",
+                "data-controller": "w-slug",
+                "data-w-slug-allow-unicode-value": "",
+                "data-w-slug-compare-as-param": "urlify",
+                "data-w-slug-locale-value": "uk-UK",  # from provided locale
+                "data-w-slug-trim-value": "true",
+                "name": "slug",
+                "type": "text",
+            },
+        )
+
+        french = Locale.objects.create(language_code="fr")
+        self.assertEqual(
+            self.getAttrs(locale=french),
+            {
+                "data-action": "blur->w-slug#slugify w-sync:check->w-slug#compare w-sync:apply->w-slug#urlify:prevent",
+                "data-controller": "w-slug",
+                "data-w-slug-allow-unicode-value": "",
+                "data-w-slug-compare-as-param": "urlify",
+                "data-w-slug-locale-value": "fr",  # from provided locale
+                "data-w-slug-trim-value": "true",
+                "name": "slug",
+                "type": "text",
+            },
+        )
+
+        self.assertEqual(
+            self.getAttrs(locale=False),
+            {
+                "data-action": "blur->w-slug#slugify w-sync:check->w-slug#compare w-sync:apply->w-slug#urlify:prevent",
+                "data-controller": "w-slug",
+                "data-w-slug-allow-unicode-value": "",
+                "data-w-slug-compare-as-param": "urlify",
+                "data-w-slug-locale-value": "und",  # from False (aka 'undetermined')
+                "data-w-slug-trim-value": "true",
+                "name": "slug",
+                "type": "text",
+            },
+        )
+
+    def test_with_locale_blank_override(self):
+        self.assertEqual(
+            self.getAttrs(locale=False)["data-w-slug-locale-value"],
+            "und",
+        )
+
+        self.assertEqual(
+            self.getAttrs(locale="")["data-w-slug-locale-value"],
+            "und",
+        )

wagtail/admin/tests/test_workflows.py

@@ -178,7 +178,7 @@ class TestWorkflowsIndexView(AdminTemplateTestUtils, WagtailTestUtils, TestCase)
         soup = self.get_soup(response.content)
         cells = [
             text
-            for td in soup.select("td")
+            for td in soup.select("main table td")
             if (text := td.get_text(separator=" | ", strip=True))
         ]
         self.assertEqual(

wagtail/admin/tests/ui/test_sidebar.py

@@ -4,6 +4,7 @@ from django.test import TestCase as DjangoTestCase
 from django.urls import reverse
 
 from wagtail.admin.search import SearchArea
+from wagtail.admin.telepath import JSContext
 from wagtail.admin.ui.sidebar import (
     ActionMenuItem,
     LinkMenuItem,
@@ -12,7 +13,6 @@ from wagtail.admin.ui.sidebar import (
     SearchModule,
     SubMenuItem,
 )
-from wagtail.telepath import JSContext
 from wagtail.test.utils import WagtailTestUtils
 
 

wagtail/admin/tests/viewsets/test_base_viewset.py

@@ -39,3 +39,8 @@ class TestBaseViewSet(WagtailTestUtils, TestCase):
         self.assertEqual(url, "/admin/greetingz/")
         self.assertContains(response, "Greetings")
         self.assertContains(response, "Welcome to this greetings page, Gordon Freeman!")
+
+    def test_method_injection(self):
+        response = self.client.get(reverse("opera:index"))
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, "Porgy and Bess")