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

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)

wagtail/admin/tests/test_privacy.py

@@ -1,5 +1,5 @@
 from django.contrib.auth.models import Group
-from django.test import TestCase
+from django.test import TestCase, override_settings
 from django.urls import reverse
 
 from wagtail.models import Page, PageViewRestriction
@@ -205,12 +205,46 @@ class TestSetPrivacyView(WagtailTestUtils, TestCase):
         history_response = self.client.get(history_url)
 
         # Check that the expected log message is present
-        expected_log_message = "Removed the 'Private, accessible with the following password' view restriction. The page is public."
+        expected_log_message = "Removed the 'Private, accessible with a shared password' view restriction. The page is public."
         self.assertContains(
             history_response,
             expected_log_message,
         )
 
+    def test_set_shared_password_page(self):
+        response = self.client.get(
+            reverse("wagtailadmin_pages:set_privacy", args=(self.public_page.id,)),
+        )
+
+        input_el = self.get_soup(response.content).select_one("[data-field-input]")
+        self.assertEqual(response.status_code, 200)
+
+        # check that input option for password is visible
+        self.assertIn("password", response.context["form"].fields)
+
+        # check that the option for password is visible
+        self.assertIsNotNone(input_el)
+
+    @override_settings(WAGTAIL_PRIVATE_PAGE_OPTIONS={"SHARED_PASSWORD": False})
+    def test_unset_shared_password_page(self):
+        response = self.client.get(
+            reverse("wagtailadmin_pages:set_privacy", args=(self.public_page.id,)),
+        )
+        self.assertEqual(response.status_code, 200)
+
+        # check that input option for password is not visible
+        self.assertNotIn("password", response.context["form"].fields)
+        self.assertFalse(
+            response.context["form"]
+            .fields["restriction_type"]
+            .valid_value(PageViewRestriction.PASSWORD)
+        )
+
+        # check that the option for password is not visible
+        self.assertNotContains(
+            response, '<div class="w-field__input" data-field-input>'
+        )
+
     def test_get_private_groups(self):
         """
         This tests that the restriction type and group fields as set correctly when a user opens the set_privacy view on a public page

wagtail/admin/tests/test_rich_text.py

@@ -3,14 +3,18 @@ import unittest
 from django.conf import settings
 from django.test import SimpleTestCase, TestCase
 from django.test.utils import override_settings
-from django.urls import reverse
+from django.urls import reverse, reverse_lazy
 
 from wagtail.admin.rich_text import DraftailRichTextArea, get_rich_text_editor_widget
-from wagtail.admin.rich_text.converters.editor_html import PageLinkHandler
+from wagtail.admin.rich_text.converters.editor_html import (
+    EditorHTMLConverter,
+    PageLinkHandler,
+)
 from wagtail.admin.rich_text.editors.draftail.features import Feature
 from wagtail.blocks import RichTextBlock
 from wagtail.models import Page, get_page_models
 from wagtail.rich_text import RichText
+from wagtail.rich_text.feature_registry import FeatureRegistry
 from wagtail.test.testapp.models import SingleEventPage
 from wagtail.test.testapp.rich_text import CustomRichTextArea, LegacyRichTextArea
 from wagtail.test.utils import WagtailTestUtils
@@ -108,7 +112,9 @@ class TestDefaultRichText(WagtailTestUtils, BaseRichTextEditHandlerTestCase):
         self.assertEqual(response.status_code, 200)
 
         # Check that draftail (default editor) initialisation is applied
-        self.assertContains(response, "window.draftail.initEditor('#id_body',")
+        # Check that data-controller and data-w-init-event-value were added after initialization
+        self.assertContains(response, 'data-controller="w-init"')
+        self.assertContains(response, 'data-w-init-event-value="w-draftail:init"')
 
         # check that media for draftail is being imported
         self.assertContains(response, "wagtailadmin/js/draftail.js")
@@ -353,10 +359,20 @@ class TestDraftailWithFeatureOptions(WagtailTestUtils, BaseRichTextEditHandlerTe
                 args=("tests", "defaultrichtextfieldpage", self.root_page.id),
             )
         )
-        self.assertEqual(response.status_code, 200)
-        self.assertContains(response, '"type": "header-two"')
-        self.assertContains(response, '"type": "IMAGE"')
-        self.assertNotContains(response, '"type": "ordered-list-item"')
+        soup = self.get_soup(response.content)
+        input = soup.find(
+            "input",
+            {
+                "data-draftail-input": "",
+                "data-controller": "w-init",
+                "data-w-init-event-value": "w-draftail:init",
+            },
+        )
+        data = input["data-w-init-detail-value"]
+
+        self.assertIn('"type": "header-two"', data)
+        self.assertIn('"type": "IMAGE"', data)
+        self.assertNotIn('"type": "ordered-list-item"', data)
 
     @unittest.expectedFailure  # TODO(telepath)
     def test_features_option_on_rich_text_block(self):
@@ -400,16 +416,28 @@ class TestDraftailWithAdditionalFeatures(
 
         self.assertEqual(response.status_code, 200)
         # default ones are there
-        self.assertContains(response, '"type": "header-two"')
-        self.assertContains(response, '"type": "LINK"')
-        self.assertContains(response, '"type": "ITALIC"')
+
+        soup = self.get_soup(response.content)
+        input = soup.find(
+            "input",
+            {
+                "data-draftail-input": "",
+                "data-controller": "w-init",
+                "data-w-init-event-value": "w-draftail:init",
+            },
+        )
+        data = input["data-w-init-detail-value"]
+
+        self.assertIn('"type": "header-two"', data)
+        self.assertIn('"type": "LINK"', data)
+        self.assertIn('"type": "ITALIC"', data)
 
         # not the additional ones.
-        self.assertNotContains(response, '"type": "CODE"')
-        self.assertNotContains(response, '"type": "blockquote"')
-        self.assertNotContains(response, '"type": "SUPERSCRIPT"')
-        self.assertNotContains(response, '"type": "SUBSCRIPT"')
-        self.assertNotContains(response, '"type": "STRIKETHROUGH"')
+        self.assertNotIn('"type": "CODE"', data)
+        self.assertNotIn('"type": "blockquote"', data)
+        self.assertNotIn('"type": "SUPERSCRIPT"', data)
+        self.assertNotIn('"type": "SUBSCRIPT"', data)
+        self.assertNotIn('"type": "STRIKETHROUGH"', data)
 
     @override_settings(
         WAGTAILADMIN_RICH_TEXT_EDITORS={
@@ -437,17 +465,29 @@ class TestDraftailWithAdditionalFeatures(
         )
 
         self.assertEqual(response.status_code, 200)
+
+        soup = self.get_soup(response.content)
+        input = soup.find(
+            "input",
+            {
+                "data-draftail-input": "",
+                "data-controller": "w-init",
+                "data-w-init-event-value": "w-draftail:init",
+            },
+        )
+
+        data = input["data-w-init-detail-value"]
         # Added features are there
-        self.assertContains(response, '"type": "header-two"')
-        self.assertContains(response, '"type": "CODE"')
-        self.assertContains(response, '"type": "blockquote"')
-        self.assertContains(response, '"type": "SUPERSCRIPT"')
-        self.assertContains(response, '"type": "SUBSCRIPT"')
-        self.assertContains(response, '"type": "STRIKETHROUGH"')
+        self.assertIn('"type": "header-two"', data)
+        self.assertIn('"type": "CODE"', data)
+        self.assertIn('"type": "blockquote"', data)
+        self.assertIn('"type": "SUPERSCRIPT"', data)
+        self.assertIn('"type": "SUBSCRIPT"', data)
+        self.assertIn('"type": "STRIKETHROUGH"', data)
 
         # But not the unprovided default ones.
-        self.assertNotContains(response, '"type": "LINK"')
-        self.assertNotContains(response, '"type": "ITALIC"')
+        self.assertNotIn('"type": "LINK"', data)
+        self.assertNotIn('"type": "ITALIC"', data)
 
 
 class TestPageLinkHandler(WagtailTestUtils, TestCase):
@@ -471,6 +511,17 @@ class TestPageLinkHandler(WagtailTestUtils, TestCase):
             % events_page_id,
         )
 
+    def test_editorhtmlconverter_from_database_format(self):
+        events_page_id = Page.objects.get(url_path="/home/events/").pk
+        db_html = '<a linktype="page" id="%d">foo</a>' % events_page_id
+        converter = EditorHTMLConverter(features=["link"])
+        editor_html = converter.from_database_format(db_html)
+        self.assertEqual(
+            editor_html,
+            '<a data-linktype="page" data-id="%d" data-parent-id="2" href="/events/">foo</a>'
+            % events_page_id,
+        )
+
 
 class TestWidgetNotHidden(SimpleTestCase):
     def test_draftail(self):
@@ -491,3 +542,97 @@ class TestDraftailFeature(SimpleTestCase):
         media_html = str(feature.media)
         self.assertRegex(media_html, r"feature.js\?v=(\w+)")
         self.assertRegex(media_html, r"feature.css\?v=(\w+)")
+
+
+class TestRichTextChooserUrls(WagtailTestUtils, BaseRichTextEditHandlerTestCase):
+    def setUp(self):
+        super().setUp()
+
+        # Find root page
+        self.root_page = Page.objects.get(id=2)
+
+        self.login()
+
+    @override_settings(
+        WAGTAILADMIN_RICH_TEXT_EDITORS={
+            "default": {
+                "WIDGET": "wagtail.admin.rich_text.DraftailRichTextArea",
+            },
+        }
+    )
+    def test_chooser_urls_exist(self):
+        features = FeatureRegistry()
+        link = features.get_editor_plugin("draftail", "link")
+
+        self.assertIsNotNone(link.data.get("chooserUrls"))
+        self.assertEqual(
+            link.data["chooserUrls"]["pageChooser"],
+            reverse_lazy("wagtailadmin_choose_page"),
+        )
+        self.assertEqual(
+            link.data["chooserUrls"]["externalLinkChooser"],
+            reverse_lazy("wagtailadmin_choose_page_external_link"),
+        )
+        self.assertEqual(
+            link.data["chooserUrls"]["emailLinkChooser"],
+            reverse_lazy("wagtailadmin_choose_page_email_link"),
+        )
+        self.assertEqual(
+            link.data["chooserUrls"]["phoneLinkChooser"],
+            reverse_lazy("wagtailadmin_choose_page_phone_link"),
+        )
+        self.assertEqual(
+            link.data["chooserUrls"]["anchorLinkChooser"],
+            reverse_lazy("wagtailadmin_choose_page_anchor_link"),
+        )
+
+    def test_lazy_chooser_urls_resolved_correctly(self):
+        response = self.client.get(
+            reverse(
+                "wagtailadmin_pages:add",
+                args=("tests", "defaultrichtextfieldpage", self.root_page.id),
+            )
+        )
+
+        soup = self.get_soup(response.content)
+        input = soup.find(
+            "input",
+            {
+                "data-draftail-input": "",
+                "data-controller": "w-init",
+                "data-w-init-event-value": "w-draftail:init",
+            },
+        )
+
+        data = input["data-w-init-detail-value"]
+
+        self.assertIn(
+            '"chooserUrls": {"imageChooser": "/admin/images/chooser/"}',
+            data,
+        )
+        self.assertIn(
+            '"chooserUrls": {"embedsChooser": "/admin/embeds/chooser/"}',
+            data,
+        )
+        self.assertIn(
+            '"chooserUrls": {"documentChooser": "/admin/documents/chooser/"}',
+            data,
+        )
+
+        self.assertIn(
+            '"chooserUrls": {"pageChooser": "/admin/choose-page/", "externalLinkChooser": "/admin/choose-external-link/", "emailLinkChooser": "/admin/choose-email-link/", "phoneLinkChooser": "/admin/choose-phone-link/", "anchorLinkChooser": "/admin/choose-anchor-link/"}',
+            data,
+        )
+
+    def test_lazy_urls_resolution(self):
+        """
+        Check that the lazy URLs have been resolved correctly in the rendered widget HTML data attributes.
+        """
+
+        widget = DraftailRichTextArea()
+        html = widget.render("test_chooserUrls", "", {})
+
+        self.assertIn("/admin/choose-page/", html)
+        self.assertIn("/admin/images/chooser/", html)
+        self.assertIn("/admin/embeds/chooser/", html)
+        self.assertIn("/admin/documents/chooser/", html)