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

wagtail/admin/tests/test_dashboard.py

@@ -0,0 +1,404 @@
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Group, Permission
+from django.contrib.contenttypes.models import ContentType
+from django.test import TestCase
+from django.urls import reverse
+from django.utils import timezone
+from freezegun import freeze_time
+
+from wagtail.admin.views.home import (
+    LockedPagesPanel,
+    RecentEditsPanel,
+    UserObjectsInWorkflowModerationPanel,
+    WorkflowObjectsToModeratePanel,
+)
+from wagtail.coreutils import get_dummy_request
+from wagtail.models import GroupPagePermission, Page, Workflow, WorkflowContentType
+from wagtail.test.testapp.models import FullFeaturedSnippet, SimplePage
+from wagtail.test.utils import WagtailTestUtils
+
+
+class TestRecentEditsPanel(WagtailTestUtils, TestCase):
+    def setUp(self):
+        # Find root page
+        self.root_page = Page.objects.get(id=2)
+
+        # Add child page
+        child_page = SimplePage(
+            title="Hello world!",
+            slug="hello-world",
+            content="Some content here",
+        )
+        self.root_page.add_child(instance=child_page)
+        self.revision = child_page.save_revision()
+        self.revision.publish()
+        self.child_page = SimplePage.objects.get(id=child_page.id)
+
+        self.user_alice = self.create_superuser(username="alice", password="password")
+        self.create_superuser(username="bob", password="password")
+
+    def change_something(self, title):
+        post_data = {"title": title, "content": "Some content", "slug": "hello-world"}
+        response = self.client.post(
+            reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)), post_data
+        )
+
+        # Should be redirected to edit page
+        self.assertRedirects(
+            response, reverse("wagtailadmin_pages:edit", args=(self.child_page.id,))
+        )
+
+        # The page should have "has_unpublished_changes" flag set
+        child_page_new = SimplePage.objects.get(id=self.child_page.id)
+        self.assertTrue(child_page_new.has_unpublished_changes)
+
+    def go_to_dashboard_response(self):
+        response = self.client.get(reverse("wagtailadmin_home"))
+        self.assertEqual(response.status_code, 200)
+        return response
+
+    def test_your_recent_edits(self):
+        # Login as Bob
+        self.login(username="bob", password="password")
+
+        # Bob hasn't edited anything yet
+        response = self.client.get(reverse("wagtailadmin_home"))
+        self.assertNotIn("Your most recent edits", response.content.decode("utf-8"))
+
+        # Login as Alice
+        self.client.logout()
+        self.login(username="alice", password="password")
+
+        # Alice changes something
+        self.change_something("Alice's edit")
+
+        # Edit should show up on dashboard
+        response = self.go_to_dashboard_response()
+        self.assertIn("Your most recent edits", response.content.decode("utf-8"))
+
+        # Bob changes something
+        self.login(username="bob", password="password")
+        self.change_something("Bob's edit")
+
+        # Edit shows up on Bobs dashboard
+        response = self.go_to_dashboard_response()
+        self.assertIn("Your most recent edits", response.content.decode("utf-8"))
+
+        # Login as Alice again
+        self.client.logout()
+        self.login(username="alice", password="password")
+
+        # Alice's dashboard should still list that first edit
+        response = self.go_to_dashboard_response()
+        self.assertIn("Your most recent edits", response.content.decode("utf-8"))
+
+    def test_missing_page_record(self):
+        # Ensure that the panel still renders when one of the page IDs returned from querying
+        # PageLogEntry has no corresponding Page object. This can happen if a page is deleted,
+        # because PageLogEntry records are kept on deletion.
+
+        self.login(username="alice", password="password")
+        self.change_something("Alice's edit")
+        self.child_page.delete()
+        response = self.client.get(reverse("wagtailadmin_home"))
+        self.assertEqual(response.status_code, 200)
+
+    def test_panel(self):
+        """Test if the panel actually returns expected pages"""
+        self.login(username="bob", password="password")
+        # change a page
+
+        edit_timestamp = timezone.now()
+        with freeze_time(edit_timestamp):
+            self.change_something("Bob's edit")
+
+        # set a user to 'mock' a request
+        self.client.user = get_user_model().objects.get(email="bob@example.com")
+        # get the panel to get the last edits
+        panel = RecentEditsPanel()
+        ctx = panel.get_context_data({"request": self.client})
+
+        page = Page.objects.get(pk=self.child_page.id).specific
+
+        # check the timestamp matches the edit
+        self.assertEqual(ctx["last_edits"][0][0], edit_timestamp)
+        # check if the page in this list is the specific page
+        self.assertEqual(ctx["last_edits"][0][1], page)
+
+    def test_copying_does_not_count_as_an_edit(self):
+        self.login(username="bob", password="password")
+        # change a page
+        self.change_something("Bob was ere")
+
+        # copy the page
+        post_data = {
+            "new_title": "Goodbye world!",
+            "new_slug": "goodbye-world",
+            "new_parent_page": str(self.root_page.id),
+            "copy_subpages": False,
+            "alias": False,
+        }
+        self.client.post(
+            reverse("wagtailadmin_pages:copy", args=(self.child_page.id,)), post_data
+        )
+        # check that page has been copied
+        self.assertTrue(Page.objects.get(title="Goodbye world!"))
+
+        response = self.client.get(reverse("wagtailadmin_home"))
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, "Your most recent edits")
+        self.assertContains(response, "Bob was ere")
+        self.assertNotContains(response, "Goodbye world!")
+
+
+class TestRecentEditsQueryCount(WagtailTestUtils, TestCase):
+    fixtures = ["test.json"]
+
+    def setUp(self):
+        self.bob = self.create_superuser(username="bob", password="password")
+        self.dummy_request = get_dummy_request()
+        self.dummy_request.user = self.bob
+        workflow = Workflow.objects.first()
+        workflow_pages = {5, 6}
+        locked_pages = {6, 9}
+        scheduled_pages = {9, 12}
+        # make a bunch of page edits (all to EventPages, so that calls to specific() don't add
+        # an unpredictable number of queries)
+        pages_to_edit = list(
+            Page.objects.filter(id__in=[4, 5, 6, 9, 12, 13]).order_by("pk").specific()
+        )
+        for page in pages_to_edit:
+            revision = page.save_revision(user=self.bob, log_action=True)
+            if page.pk in workflow_pages:
+                workflow.start(page, self.bob)
+            if page.pk in locked_pages:
+                page.locked = True
+                page.locked_by = self.bob
+                page.locked_at = timezone.now()
+                page.save()
+            if page.pk in scheduled_pages:
+                revision.approved_go_live_at = timezone.now()
+                revision.save()
+
+    def test_panel_query_count(self):
+        panel = RecentEditsPanel()
+        parent_context = {"request": self.dummy_request}
+        # Warm up the cache
+        html = panel.render_html(parent_context)
+
+        with self.assertNumQueries(5):
+            # Rendering RecentEditsPanel should not generate N+1 queries -
+            # i.e. any number less than 6 would be reasonable here
+            html = panel.render_html(parent_context)
+        # check that the panel is still actually returning results
+        self.assertIn("Ameristralia Day", html)
+        soup = self.get_soup(html)
+        self.assertEqual(len(soup.select('svg use[href="#icon-lock"]')), 2)
+        expected_statuses = [
+            "live + draft",
+            "live + scheduled",
+            "live + scheduled",
+            "in moderation",
+            "in moderation",
+        ]
+        statuses = [
+            "".join(e.find_all(string=True, recursive=False)).strip()
+            for e in soup.select(".w-status")
+        ]
+        self.assertEqual(statuses, expected_statuses)
+
+
+class TestLockedPagesQueryCount(WagtailTestUtils, TestCase):
+    fixtures = ["test.json"]
+
+    def setUp(self):
+        self.bob = self.create_superuser(username="bob", password="password")
+        self.dummy_request = get_dummy_request()
+        self.dummy_request.user = self.bob
+
+        pages = Page.objects.filter(pk__in=[9, 12, 13]).order_by("pk")
+        for i, page in enumerate(pages):
+            page.locked = True
+            page.locked_by = self.bob
+            page.locked_at = timezone.now() + timezone.timedelta(hours=i)
+            page.save()
+
+    def test_panel_query_count(self):
+        panel = LockedPagesPanel()
+        parent_context = {"request": self.dummy_request, "csrf_token": "dummy"}
+        # Warm up the cache
+        html = panel.render_html(parent_context)
+
+        with self.assertNumQueries(1):
+            html = panel.render_html(parent_context)
+        soup = self.get_soup(html)
+        # Should be sorted descending by locked_at
+        expected_titles = [
+            "Saint Patrick (single event)",
+            "Steal underpants",
+            "Ameristralia Day",
+        ]
+        titles = [e.get_text(strip=True) for e in soup.select(".title-wrapper a")]
+        self.assertEqual(titles, expected_titles)
+
+
+class UserObjectsInWorkflowModerationQueryCount(WagtailTestUtils, TestCase):
+    fixtures = ["test.json"]
+
+    def setUp(self):
+        self.superuser = self.create_superuser(username="admin", password="password")
+        self.bob = self.create_user(username="bob", password="password")
+        self.someone_else = self.create_user(
+            username="someoneelse", password="password"
+        )
+        editors = Group.objects.get(name="Editors")
+        editors.user_set.add(self.bob, self.someone_else)
+
+        workflow = Workflow.objects.first()
+        WorkflowContentType.objects.create(
+            workflow=workflow,
+            content_type=ContentType.objects.get_for_model(FullFeaturedSnippet),
+        )
+        GroupPagePermission.objects.create(
+            group=editors, page=Page.get_first_root_node(), permission_type="change"
+        )
+        editors.permissions.add(
+            Permission.objects.get(codename="change_fullfeaturedsnippet")
+        )
+
+        # Pages owned by bob, but workflow started by someone else
+        Page.objects.filter(id__in=[9, 12]).update(owner=self.bob)
+        for page in Page.objects.filter(id__in=[9, 12]).specific():
+            page.save_revision()
+            workflow.start(page, self.someone_else)
+            # Lock it to test the lock indicator
+            page.locked = True
+            page.locked_by = self.superuser
+            page.locked_at = timezone.now()
+            page.save()
+
+        # Page workflow started by bob
+        for page in Page.objects.filter(id__in=[4, 13]).specific():
+            page.save_revision()
+            workflow.start(page, self.bob)
+
+        # Snippet workflow started by bob
+        for i in range(1, 3):
+            obj = FullFeaturedSnippet.objects.create(text=f"Some obj {i}")
+            obj.save_revision()
+            workflow.start(obj, self.bob)
+
+        self.dummy_request = get_dummy_request()
+        self.dummy_request.user = self.bob
+
+    def test_panel_query_count(self):
+        panel = UserObjectsInWorkflowModerationPanel()
+        parent_context = {"request": self.dummy_request}
+        # Warm up the cache
+        html = panel.render_html(parent_context)
+
+        with self.assertNumQueries(4):
+            html = panel.render_html(parent_context)
+
+        soup = self.get_soup(html)
+        self.assertEqual(len(soup.select('svg use[href="#icon-lock"]')), 2)
+        expected_titles = [
+            "Some obj 2",
+            "Some obj 1",
+            "Saint Patrick (single event)",
+            "Christmas",
+            "Steal underpants",
+            "Ameristralia Day",
+        ]
+        titles = [e.get_text(strip=True) for e in soup.select(".title-wrapper a")]
+        self.assertEqual(titles, expected_titles)
+
+
+class WorkflowObjectsToModerateQueryCount(WagtailTestUtils, TestCase):
+    fixtures = ["test.json"]
+
+    def setUp(self):
+        self.superuser = self.create_superuser(username="admin", password="password")
+        self.bob = self.create_user(username="bob", password="password")
+        self.moderator = self.create_user(username="moderator", password="password")
+
+        editors = Group.objects.get(name="Editors")
+        moderators = Group.objects.get(name="Moderators")
+
+        editors.user_set.add(self.bob)
+        moderators.user_set.add(self.moderator)
+
+        root = Page.get_first_root_node()
+        GroupPagePermission.objects.create(
+            group=editors, page=root, permission_type="change"
+        )
+        GroupPagePermission.objects.create(
+            group=moderators, page=root, permission_type="change"
+        )
+        GroupPagePermission.objects.create(
+            group=moderators, page=root, permission_type="publish"
+        )
+
+        editors.permissions.add(
+            Permission.objects.get(codename="change_fullfeaturedsnippet")
+        )
+        moderators.permissions.add(
+            *Permission.objects.filter(
+                codename__in=[
+                    "change_fullfeaturedsnippet",
+                    "publish_fullfeaturedsnippet",
+                ]
+            ),
+        )
+
+        workflow = Workflow.objects.first()
+        WorkflowContentType.objects.create(
+            workflow=workflow,
+            content_type=ContentType.objects.get_for_model(FullFeaturedSnippet),
+        )
+
+        # Pages workflow started by bob and locked by moderator
+        for page in Page.objects.filter(id__in=[9, 12]).specific():
+            page.save_revision()
+            workflow.start(page, self.bob)
+            # Lock it to test the lock indicator
+            page.locked = True
+            page.locked_by = self.moderator
+            page.locked_at = timezone.now()
+            page.save()
+
+        # Page workflow started by bob
+        for page in Page.objects.filter(id__in=[4, 13]).specific():
+            page.save_revision()
+            workflow.start(page, self.bob)
+
+        # Snippet workflow started by bob
+        for i in range(1, 3):
+            obj = FullFeaturedSnippet.objects.create(text=f"Some obj {i}")
+            obj.save_revision()
+            workflow.start(obj, self.bob)
+
+        self.dummy_request = get_dummy_request()
+        self.dummy_request.user = self.moderator
+
+    def test_panel_query_count(self):
+        panel = WorkflowObjectsToModeratePanel()
+        parent_context = {"request": self.dummy_request, "csrf_token": "dummy"}
+        # Warm up the cache
+        html = panel.render_html(parent_context)
+
+        with self.assertNumQueries(13):
+            html = panel.render_html(parent_context)
+
+        soup = self.get_soup(html)
+        self.assertEqual(len(soup.select('svg use[href="#icon-lock"]')), 2)
+        expected_titles = [
+            "Some obj 2",
+            "Some obj 1",
+            "Saint Patrick (single event)",
+            "Christmas",
+            "Steal underpants",
+            "Ameristralia Day",
+        ]
+        titles = [e.get_text(strip=True) for e in soup.select(".title-wrapper a")]
+        self.assertEqual(titles, expected_titles)

wagtail/admin/tests/test_dbwhitelister.py

@@ -9,7 +9,7 @@ class TestDbWhitelisterMethods(WagtailTestUtils, TestCase):
         self.whitelister = EditorHTMLConverter().whitelister
 
     def test_clean_tag_node_div(self):
-        soup = self.get_soup("<div>foo</div>", "html5lib")
+        soup = self.get_soup("<div>foo</div>")
         tag = soup.div
         self.assertEqual(tag.name, "div")
         self.whitelister.clean_tag_node(soup, tag)
@@ -18,7 +18,6 @@ class TestDbWhitelisterMethods(WagtailTestUtils, TestCase):
     def test_clean_tag_node_with_data_embedtype(self):
         soup = self.get_soup(
             '<p><a data-embedtype="image" data-id=1 data-format="left" data-alt="bar" irrelevant="baz">foo</a></p>',
-            "html5lib",
         )
         tag = soup.p
         self.whitelister.clean_tag_node(soup, tag)
@@ -29,14 +28,13 @@ class TestDbWhitelisterMethods(WagtailTestUtils, TestCase):
     def test_clean_tag_node_with_data_linktype(self):
         soup = self.get_soup(
             '<a data-linktype="document" data-id="1" irrelevant="baz">foo</a>',
-            "html5lib",
         )
         tag = soup.a
         self.whitelister.clean_tag_node(soup, tag)
         self.assertEqual(str(tag), '<a id="1" linktype="document">foo</a>')
 
     def test_clean_tag_node(self):
-        soup = self.get_soup('<a irrelevant="baz">foo</a>', "html5lib")
+        soup = self.get_soup('<a irrelevant="baz">foo</a>')
         tag = soup.a
         self.whitelister.clean_tag_node(soup, tag)
         self.assertEqual(str(tag), "<a>foo</a>")
@@ -52,7 +50,8 @@ class TestDbWhitelister(WagtailTestUtils, TestCase):
         (necessary because we can't guarantee the order that attributes are output in)
         """
         self.assertEqual(
-            self.get_soup(str1, "html5lib"), self.get_soup(str2, "html5lib")
+            self.get_soup(str1),
+            self.get_soup(str2),
         )
 
     def test_page_link_is_rewritten(self):

wagtail/admin/tests/test_edit_handlers.py

@@ -189,7 +189,7 @@ class TestGetFormForModel(TestCase):
         self.assertIn("speakers", form.formsets)
         self.assertNotIn("related_links", form.formsets)
 
-    def test_get_form_for_model_with_widget_overides_by_class(self):
+    def test_get_form_for_model_with_widget_overrides_by_class(self):
         EventPageForm = get_form_for_model(
             EventPage,
             form_class=WagtailAdminPageForm,
@@ -201,7 +201,7 @@ class TestGetFormForModel(TestCase):
         self.assertEqual(type(form.fields["date_from"]), forms.DateField)
         self.assertEqual(type(form.fields["date_from"].widget), forms.PasswordInput)
 
-    def test_get_form_for_model_with_widget_overides_by_instance(self):
+    def test_get_form_for_model_with_widget_overrides_by_instance(self):
         EventPageForm = get_form_for_model(
             EventPage,
             form_class=WagtailAdminPageForm,

wagtail/admin/tests/test_keyboard_shortcuts.py

@@ -0,0 +1,84 @@
+import json
+import re
+
+from django.test import TestCase
+from django.test.client import Client
+from django.urls import reverse
+
+from wagtail.test.utils import WagtailTestUtils
+
+
+class TestKeyboardShortcutsDialog(WagtailTestUtils, TestCase):
+    def setUp(self):
+        self.login()
+
+    def test_keyboard_shortcuts_trigger_in_sidebar(self):
+        response = self.client.get(reverse("wagtailadmin_home"))
+        self.assertEqual(response.status_code, 200)
+
+        sidebar_data = (
+            self.get_soup(response.content)
+            .select_one("#wagtail-sidebar-props")
+            .contents[0]
+        )
+
+        self.assertIn(
+            json.dumps(
+                {
+                    "role": "button",
+                    "data-a11y-dialog-show": "keyboard-shortcuts-dialog",
+                    "data-action": "w-action#noop:prevent:stop",
+                    "data-controller": "w-action",
+                }
+            ),
+            sidebar_data,
+        )
+
+    def test_keyboard_shortcuts_dialog(self):
+        response = self.client.get(reverse("wagtailadmin_home"))
+
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(
+            response, "wagtailadmin/shared/keyboard_shortcuts_dialog.html"
+        )
+
+        soup = self.get_soup(response.content)
+
+        # Check that the keyboard shortcuts dialog is present
+        shortcuts_dialog = soup.select_one("#keyboard-shortcuts-dialog")
+        self.assertIsNotNone(shortcuts_dialog)
+
+        # Check that the keyboard shortcuts dialog has basic accessible content
+        self.assertIn(
+            "All keyboard shortcuts", shortcuts_dialog.find("caption").prettify()
+        )
+        self.assertIn("Keyboard shortcut", shortcuts_dialog.find("thead").prettify())
+
+
+class TestMacKeyboardShortcutsDialog(WagtailTestUtils, TestCase):
+    def setUp(self):
+        # Creates a client with a Mac user agent
+        self.client = Client(
+            headers={
+                "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36"
+            }
+        )
+        self.login()
+
+    def test_mac_useragent_and_behavior(self):
+        response = self.client.get(reverse("wagtailadmin_home"))
+
+        # Check that the user agent is a Mac
+        user_agent = response.context["request"].headers.get("User-Agent", "")
+        is_mac = re.search(r"Mac|iPod|iPhone|iPad", user_agent)
+
+        # Add assertions based on expected Mac behavior
+        self.assertTrue(is_mac)
+
+        # Check that the keyboard shortcuts dialog has Mac-specific content
+        soup = self.get_soup(response.content)
+        shortcuts_dialog = soup.select_one("#keyboard-shortcuts-dialog")
+        all_shortcuts = shortcuts_dialog.select("kbd")
+        for shortcut in all_shortcuts:
+            # All shortcuts should have the ⌘ symbol
+            self.assertIn("⌘", shortcut.prettify())

wagtail/admin/tests/test_page_chooser.py

@@ -4,6 +4,7 @@ import urllib.parse as urlparse
 from django.contrib.auth import get_user_model
 from django.test import TestCase, TransactionTestCase, override_settings
 from django.urls import reverse
+from django.utils.html import escape
 from django.utils.http import urlencode
 
 from wagtail.admin.views.chooser import can_choose_page
@@ -1253,7 +1254,7 @@ class TestPageChooserLocaleSelector(WagtailTestUtils, TestCase):
         self.child_page_fr.save()
 
         switch_to_french_url = self.get_choose_page_url(
-            self.fr_locale, parent_page_id=self.child_page_fr.pk
+            parent_page_id=self.child_page_fr.pk
         )
         self.LOCALE_SELECTOR_HTML_FR = (
             f'<a href="{switch_to_french_url}" data-locale-selector-link>'
@@ -1266,20 +1267,12 @@ class TestPageChooserLocaleSelector(WagtailTestUtils, TestCase):
             reverse("wagtailadmin_choose_page_child", args=[parent_page_id])
         )
 
-    def get_choose_page_url(self, locale=None, parent_page_id=None, html=True):
+    def get_choose_page_url(self, parent_page_id=None, params=""):
         if parent_page_id is not None:
             url = reverse("wagtailadmin_choose_page_child", args=[parent_page_id])
         else:
             url = reverse("wagtailadmin_choose_page")
-
-        suffix = ""
-        if parent_page_id is None:
-            # the locale param should only be appended at the root level
-            if locale is None:
-                locale = self.fr_locale
-            separator = "&amp;" if html else "&"
-            suffix = f"{separator}locale={locale.language_code}"
-        return f"{url}?page_type=wagtailcore.page{suffix}"
+        return f"{url}?{params}"
 
     def test_locale_selector_present_in_root_view(self):
         response = self.client.get(reverse("wagtailadmin_choose_page"))
@@ -1287,7 +1280,7 @@ class TestPageChooserLocaleSelector(WagtailTestUtils, TestCase):
 
         self.assertRegex(html, self.LOCALE_SELECTOR_HTML)
 
-        switch_to_french_url = self.get_choose_page_url(locale=self.fr_locale)
+        switch_to_french_url = self.get_choose_page_url(params="locale=fr")
         fr_selector = f'<a href="{switch_to_french_url}" data-locale-selector-link>'
         self.assertIn(fr_selector, html)
 
@@ -1306,9 +1299,7 @@ class TestPageChooserLocaleSelector(WagtailTestUtils, TestCase):
         self.assertNotIn("data-locale-selector", html)
 
     def test_locale_selector_with_active_locale(self):
-        switch_to_french_url = self.get_choose_page_url(
-            locale=self.fr_locale, html=False
-        )
+        switch_to_french_url = self.get_choose_page_url(params="locale=fr")
         response = self.client.get(switch_to_french_url)
         html = response.json().get("html")
 
@@ -1319,9 +1310,7 @@ class TestPageChooserLocaleSelector(WagtailTestUtils, TestCase):
             html,
             r"data-locale-selector[^<]+<button[^<]+<svg[^<]+<use[^<]+<\/use[^<]+<\/svg[^<]+French",
         )
-        switch_to_english_url = self.get_choose_page_url(
-            locale=Locale.objects.get(language_code="en")
-        )
+        switch_to_english_url = self.get_choose_page_url(params="locale=en")
         self.assertIn(
             f'<a href="{switch_to_english_url}" data-locale-selector-link>',
             html,
@@ -1332,3 +1321,27 @@ class TestPageChooserLocaleSelector(WagtailTestUtils, TestCase):
         response = self.get(self.child_page.pk)
         html = response.json().get("html")
         self.assertNotIn("data-locale-selector", html)
+
+    def test_query_params_preserved(self):
+        choose_url = reverse(
+            "wagtailadmin_choose_page_child", args=[self.child_page.pk]
+        )
+        params = "can_choose_root=false&user_perms=copy_to&match_subclass=true"
+        response = self.client.get(f"{choose_url}?{params}&p=1")
+        html = response.json().get("html")
+        self.assertIn("data-locale-selector", html)
+
+        switch_to_french_url = self.get_choose_page_url(
+            parent_page_id=self.child_page_fr.pk, params=params
+        )
+        self.assertIn(escape(switch_to_french_url), html)
+
+    def test_query_params_preserved_in_root_view(self):
+        choose_url = reverse("wagtailadmin_choose_page")
+        params = "can_choose_root=false&user_perms=copy_to&match_subclass=true"
+        response = self.client.get(f"{choose_url}?{params}&p=1")
+        html = response.json().get("html")
+        self.assertIn("data-locale-selector", html)
+
+        switch_to_french_url = self.get_choose_page_url(params=params + "&locale=fr")
+        self.assertIn(escape(switch_to_french_url), html)