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

wagtail/snippets/tests/test_reordering.py

@@ -0,0 +1,319 @@
+from django.contrib.admin.utils import quote
+from django.contrib.auth import get_permission_codename
+from django.contrib.auth.models import Permission
+from django.test import TestCase
+from django.urls import reverse
+
+from wagtail.test.testapp.models import FullFeaturedSnippet
+from wagtail.test.utils import WagtailTestUtils
+
+
+class TestIndexViewReordering(WagtailTestUtils, TestCase):
+    def setUp(self):
+        self.user = self.login()
+        # This model extends Orderable, thus it has a sort_order_field on the model
+        # and we don't need to set it on the viewset.
+        self.obj1 = FullFeaturedSnippet.objects.create(text="Toy 1", sort_order=0)
+        self.obj2 = FullFeaturedSnippet.objects.create(text="Toy 2", sort_order=1)
+        self.obj3 = FullFeaturedSnippet.objects.create(text="Toy 3", sort_order=2)
+
+    def get_url_name(self, name):
+        return FullFeaturedSnippet.snippet_viewset.get_url_name(name)
+
+    def test_header_button_rendered(self):
+        index_url = reverse(self.get_url_name("list"))
+        custom_ordering_url = index_url + "?ordering=sort_order"
+        response = self.client.get(index_url)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        button = soup.select_one(
+            f".w-slim-header .w-dropdown a[href='{custom_ordering_url}']"
+        )
+        self.assertIsNotNone(button)
+        self.assertEqual(button.text.strip(), "Sort item order")
+
+        # Reordering feature disabled when not sorting by sort_order,
+        # the bulk actions column is present instead
+        table = soup.select_one("main table")
+        self.assertIsNotNone(table)
+        self.assertFalse(table.get("data-controller"))
+        bulk_actions_all = soup.select_one(
+            "main thead th:first-child input[type='checkbox']"
+        )
+        self.assertIsNotNone(bulk_actions_all)
+        self.assertTrue(
+            bulk_actions_all.has_attr("data-bulk-action-select-all-checkbox")
+        )
+
+    def test_show_ordering_column(self):
+        index_url = reverse(self.get_url_name("list"))
+        custom_ordering_url = index_url + "?ordering=sort_order"
+        response = self.client.get(custom_ordering_url)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+
+        # The table should have the w-orderable controller
+        table = soup.select_one("main table")
+        self.assertIsNotNone(table)
+        self.assertEqual(table.get("data-controller"), "w-orderable")
+        self.assertEqual(
+            table.get("data-w-orderable-message-value"),
+            "'__LABEL__' has been moved successfully.",
+        )
+        self.assertEqual(
+            table.get("data-w-orderable-url-value"),
+            reverse(self.get_url_name("reorder"), args=[999999]),
+        )
+
+        # The bulk actions column should not be present
+        bulk_actions_all = table.select_one(
+            "thead th:first-child input[type='checkbox']"
+        )
+        self.assertIsNone(bulk_actions_all)
+
+        # The ordering column added as the first column
+        first_th = table.select_one("thead th:first-child")
+        self.assertIsNotNone(first_th)
+        self.assertEqual(first_th.text.strip(), "Sort")
+
+        # All rows have the corresponding attributes for reordering
+        rows = table.select("tbody tr")
+        self.assertEqual(len(rows), 3)
+        expected = [
+            {
+                "id": f"item_{quote(obj.pk)}",
+                "data-w-orderable-item-id": str(quote(obj.pk)),
+                "data-w-orderable-item-label": str(obj),
+                "data-w-orderable-target": "item",
+            }
+            for obj in [self.obj1, self.obj2, self.obj3]
+        ]
+        for row, expected_attrs in zip(rows, expected):
+            for attr, value in expected_attrs.items():
+                self.assertEqual(row.get(attr), value)
+            handle = row.select_one("td button[data-w-orderable-target='handle']")
+            self.assertIsNotNone(handle)
+
+    def test_reordering_disabled_with_insufficient_permission(self):
+        self.user.is_superuser = False
+        self.user.save()
+        admin_permission = Permission.objects.get(
+            content_type__app_label="wagtailadmin", codename="access_admin"
+        )
+        view_permission = Permission.objects.get(
+            content_type__app_label=self.obj1._meta.app_label,
+            codename=get_permission_codename("view", self.obj1._meta),
+        )
+        # Even with `change` permission, the reordering feature is not enabled
+        # because the model uses DraftStateMixin
+        change_permission = Permission.objects.get(
+            content_type__app_label=self.obj1._meta.app_label,
+            codename=get_permission_codename("change", self.obj1._meta),
+        )
+        self.user.user_permissions.add(
+            admin_permission, view_permission, change_permission
+        )
+
+        index_url = reverse(self.get_url_name("list"))
+        custom_ordering_url = index_url + "?ordering=sort_order"
+        response = self.client.get(custom_ordering_url)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+
+        # Header button for enabling reordering should not be rendered
+        button = soup.select_one(
+            f".w-slim-header .w-dropdown a[href='{custom_ordering_url}']"
+        )
+        self.assertIsNone(button)
+
+        # Reordering feature not enabled
+        table = soup.select_one("main table")
+        self.assertIsNotNone(table)
+        self.assertFalse(table.get("data-controller"))
+        bulk_actions_all = soup.select_one(
+            "main thead th:first-child input[type='checkbox']"
+        )
+        self.assertIsNotNone(bulk_actions_all)
+        self.assertTrue(
+            bulk_actions_all.has_attr("data-bulk-action-select-all-checkbox")
+        )
+
+    def test_minimal_permission(self):
+        self.user.is_superuser = False
+        self.user.save()
+        admin_permission = Permission.objects.get(
+            content_type__app_label="wagtailadmin", codename="access_admin"
+        )
+        change_permission = Permission.objects.get(
+            content_type__app_label=self.obj1._meta.app_label,
+            codename=get_permission_codename("change", self.obj1._meta),
+        )
+        publish_permission = Permission.objects.get(
+            content_type__app_label=self.obj1._meta.app_label,
+            codename=get_permission_codename("publish", self.obj1._meta),
+        )
+        self.user.user_permissions.add(
+            admin_permission,
+            change_permission,
+            publish_permission,
+        )
+
+        self.test_header_button_rendered()
+        self.test_show_ordering_column()
+
+
+class TestCreateViewReordering(WagtailTestUtils, TestCase):
+    def setUp(self):
+        self.user = self.login()
+        FullFeaturedSnippet.objects.create(text="Toy 1", sort_order=0)
+        FullFeaturedSnippet.objects.create(text="Toy 2", sort_order=1)
+        FullFeaturedSnippet.objects.create(text="Toy 3", sort_order=2)
+
+    def test_create_sets_max_sort_order(self):
+        response = self.client.post(
+            reverse(FullFeaturedSnippet.snippet_viewset.get_url_name("add")),
+            data={"text": "New Toy"},
+        )
+        new_toy = FullFeaturedSnippet.objects.get(text="New Toy")
+        self.assertRedirects(
+            response,
+            reverse(
+                FullFeaturedSnippet.snippet_viewset.get_url_name("edit"),
+                args=(quote(new_toy.pk),),
+            ),
+        )
+        new_toy = FullFeaturedSnippet.objects.get(text="New Toy")
+        self.assertEqual(new_toy.sort_order, 3)
+
+
+class TestReorderView(WagtailTestUtils, TestCase):
+    def setUp(self):
+        self.user = self.login()
+        # We don't do any normalization, so the sort_order values may not be
+        # consecutive integers (e.g. after an item is deleted), and the update
+        # logic may cause the sort_order values to be negative or larger than
+        # the number of items in the queryset.
+        self.obj1 = FullFeaturedSnippet.objects.create(text="Toy 1", sort_order=0)
+        self.obj2 = FullFeaturedSnippet.objects.create(text="Toy 2", sort_order=1)
+        self.obj3 = FullFeaturedSnippet.objects.create(text="Toy 3", sort_order=2)
+
+    def get_url(self, obj):
+        return reverse(
+            FullFeaturedSnippet.snippet_viewset.get_url_name("reorder"),
+            args=(quote(obj.pk),),
+        )
+
+    def assertOrder(self, objs):
+        self.assertSequenceEqual(
+            [
+                (obj, obj.sort_order)
+                for obj in FullFeaturedSnippet.objects.order_by("sort_order")
+            ],
+            objs,
+        )
+
+    def test_get_request_does_not_alter_order(self):
+        response = self.client.get(self.get_url(self.obj1))
+        self.assertEqual(response.status_code, 405)
+
+        # Ensure item order does not change
+        self.assertOrder([(self.obj1, 0), (self.obj2, 1), (self.obj3, 2)])
+
+    def test_post_request_without_position_argument_moves_to_the_end(self):
+        response = self.client.post(self.get_url(self.obj1))
+        self.assertEqual(response.status_code, 200)
+
+        # The item will be moved to the last position by taking the sort_order
+        # of the last item, and the sort_order of the other items updated by -1
+        self.assertOrder([(self.obj2, 0), (self.obj3, 1), (self.obj1, 2)])
+
+    def test_post_request_with_non_integer_position_moves_to_the_end(self):
+        response = self.client.post(self.get_url(self.obj1) + "?position=good")
+        self.assertEqual(response.status_code, 200)
+
+        # The item will be moved to the last position by taking the sort_order
+        # of the last item, and the sort_order of the other items updated by -1
+        self.assertOrder([(self.obj2, 0), (self.obj3, 1), (self.obj1, 2)])
+
+    def test_move_position_up(self):
+        # Move obj3 to the first position
+        response = self.client.post(self.get_url(self.obj3) + "?position=0")
+        self.assertEqual(response.status_code, 200)
+
+        # Check if obj3 is now the first item by taking obj1's sort_order and
+        # incrementing sort_order of the other items after it (but before obj3's
+        # old position) by 1
+        self.assertOrder([(self.obj3, 0), (self.obj1, 1), (self.obj2, 2)])
+
+    def test_move_position_down(self):
+        # Move obj1 to the second position
+        response = self.client.post(self.get_url(self.obj1) + "?position=1")
+        self.assertEqual(response.status_code, 200)
+
+        # Check if obj1 is now the second item by taking obj2's sort_order
+        # and decreasing sort_order of the other items before it by 1
+        self.assertOrder([(self.obj2, 0), (self.obj1, 1), (self.obj3, 2)])
+
+    def test_move_position_to_same_position(self):
+        # Move obj1 to position 0 (where it already is)
+        response = self.client.post(self.get_url(self.obj1) + "?position=0")
+        self.assertEqual(response.status_code, 200)
+
+        # Ensure item order does not change
+        self.assertOrder([(self.obj1, 0), (self.obj2, 1), (self.obj3, 2)])
+
+    def test_move_position_with_invalid_target_position(self):
+        response = self.client.post(self.get_url(self.obj1) + "?position=99")
+        self.assertEqual(response.status_code, 200)
+
+        # The item will be moved to the last position by taking the sort_order
+        # of the last item, and the sort_order of the other items updated by -1
+        self.assertOrder([(self.obj2, 0), (self.obj3, 1), (self.obj1, 2)])
+
+    def test_insufficient_permission(self):
+        self.user.is_superuser = False
+        self.user.save()
+        admin_permission = Permission.objects.get(
+            content_type__app_label="wagtailadmin", codename="access_admin"
+        )
+        view_permission = Permission.objects.get(
+            content_type__app_label=self.obj1._meta.app_label,
+            codename=get_permission_codename("view", self.obj1._meta),
+        )
+        self.user.user_permissions.add(admin_permission, view_permission)
+
+        response = self.client.post(self.get_url(self.obj1) + "?position=1")
+        self.assertEqual(response.status_code, 302)
+        self.assertRedirects(response, reverse("wagtailadmin_home"))
+        self.assertOrder([(self.obj1, 0), (self.obj2, 1), (self.obj3, 2)])
+
+        # `change` permission is not enough if the model uses DraftStateMixin
+        change_permission = Permission.objects.get(
+            content_type__app_label=self.obj1._meta.app_label,
+            codename=get_permission_codename("change", self.obj1._meta),
+        )
+        self.user.user_permissions.add(admin_permission, change_permission)
+
+        response = self.client.post(self.get_url(self.obj1) + "?position=1")
+        self.assertEqual(response.status_code, 302)
+        self.assertRedirects(response, reverse("wagtailadmin_home"))
+        self.assertOrder([(self.obj1, 0), (self.obj2, 1), (self.obj3, 2)])
+
+    def test_minimal_permission(self):
+        self.user.is_superuser = False
+        self.user.save()
+        admin_permission = Permission.objects.get(
+            content_type__app_label="wagtailadmin", codename="access_admin"
+        )
+        publish_permission = Permission.objects.get(
+            content_type__app_label=self.obj1._meta.app_label,
+            codename=get_permission_codename("publish", self.obj1._meta),
+        )
+        self.user.user_permissions.add(admin_permission, publish_permission)
+
+        response = self.client.post(self.get_url(self.obj1) + "?position=1")
+        self.assertEqual(response.status_code, 200)
+
+        # Check if obj1 is now the second item by taking obj2's sort_order
+        # and decrementing sort_order of the other items before it by 1
+        self.assertOrder([(self.obj2, 0), (self.obj1, 1), (self.obj3, 2)])

wagtail/snippets/tests/test_snippets.py

@@ -999,12 +999,33 @@ class TestSnippetCreateView(WagtailTestUtils, TestCase):
 
     def test_create_invalid(self):
         response = self.post(post_data={"foo": "bar"})
-        self.assertContains(response, "The advert could not be created due to errors.")
-        self.assertContains(response, "error-message", count=1)
-        self.assertContains(response, "This field is required", count=1)
 
         soup = self.get_soup(response.content)
 
+        header_messages = soup.css.select(".messages[role='status'] ul > li")
+
+        # there should be one header message that indicates the issue and has a go to error button
+        self.assertEqual(len(header_messages), 1)
+        message = header_messages[0]
+        self.assertIn(
+            "The advert could not be created due to errors.", message.get_text()
+        )
+        buttons = message.find_all("button")
+        self.assertEqual(len(buttons), 1)
+        self.assertEqual(buttons[0].attrs["data-controller"], "w-count w-focus")
+        self.assertEqual(
+            set(buttons[0].attrs["data-action"].split()),
+            {"click->w-focus#focus", "wagtail:panel-init@document->w-count#count"},
+        )
+        self.assertIn("Go to the first error", buttons[0].get_text())
+
+        # field specific error should be shown
+        error_messages = soup.css.select(".error-message")
+        self.assertEqual(len(error_messages), 1)
+        error_message = error_messages[0]
+        self.assertEqual(error_message.parent["id"], "panel-child-text-errors")
+        self.assertIn("This field is required", error_message.get_text())
+
         # Should have the unsaved controller set up
         editor_form = soup.select_one("#w-editor-form")
         self.assertIsNotNone(editor_form)
@@ -1773,7 +1794,7 @@ class TestCreateDraftStateSnippet(WagtailTestUtils, TestCase):
         self.assertFormError(
             response.context["form"],
             "expire_at",
-            "Expiry date/time must be in the future",
+            "Expiry date/time must be in the future.",
         )
 
         self.assertContains(
@@ -1992,12 +2013,34 @@ class TestSnippetEditView(BaseTestSnippetEditView):
 
     def test_edit_invalid(self):
         response = self.post(post_data={"foo": "bar"})
-        self.assertContains(response, "The advert could not be saved due to errors.")
-        self.assertContains(response, "error-message", count=1)
-        self.assertContains(response, "This field is required", count=1)
-
         soup = self.get_soup(response.content)
 
+        header_messages = soup.css.select(".messages[role='status'] ul > li")
+
+        # the top level message should indicate that the page could not be saved
+        self.assertEqual(len(header_messages), 1)
+        message = header_messages[0]
+        self.assertIn(
+            "The advert could not be saved due to errors.", message.get_text()
+        )
+
+        # the top level message should provide a go to error button
+        buttons = message.find_all("button")
+        self.assertEqual(len(buttons), 1)
+        self.assertEqual(buttons[0].attrs["data-controller"], "w-count w-focus")
+        self.assertEqual(
+            set(buttons[0].attrs["data-action"].split()),
+            {"click->w-focus#focus", "wagtail:panel-init@document->w-count#count"},
+        )
+        self.assertIn("Go to the first error", buttons[0].get_text())
+
+        # the error should only appear once: against the field, not in the header message
+        error_messages = soup.css.select(".error-message")
+        self.assertEqual(len(error_messages), 1)
+        error_message = error_messages[0]
+        self.assertEqual(error_message.parent["id"], "panel-child-text-errors")
+        self.assertIn("This field is required", error_message.get_text())
+
         # Should have the unsaved controller set up
         editor_form = soup.select_one("#w-editor-form")
         self.assertIsNotNone(editor_form)
@@ -3086,7 +3129,7 @@ class TestEditDraftStateSnippet(BaseTestSnippetEditView):
         self.assertFormError(
             response.context["form"],
             "expire_at",
-            "Expiry date/time must be in the future",
+            "Expiry date/time must be in the future.",
         )
 
         self.assertContains(
@@ -5972,11 +6015,33 @@ class TestSnippetViewWithCustomPrimaryKey(WagtailTestUtils, TestCase):
 
     def test_edit_invalid(self):
         response = self.post(self.snippet_a, post_data={"foo": "bar"})
-        self.assertContains(
-            response,
+        soup = self.get_soup(response.content)
+        header_messages = soup.css.select(".messages[role='status'] ul > li")
+
+        # the top level message should indicate that the page could not be saved
+        self.assertEqual(len(header_messages), 1)
+        message = header_messages[0]
+        self.assertIn(
             "The standard snippet with custom primary key could not be saved due to errors.",
+            message.get_text(),
+        )
+
+        # the top level message should provide a go to error button
+        buttons = message.find_all("button")
+        self.assertEqual(len(buttons), 1)
+        self.assertEqual(buttons[0].attrs["data-controller"], "w-count w-focus")
+        self.assertEqual(
+            set(buttons[0].attrs["data-action"].split()),
+            {"click->w-focus#focus", "wagtail:panel-init@document->w-count#count"},
         )
-        self.assertContains(response, "This field is required.")
+        self.assertIn("Go to the first error", buttons[0].get_text())
+
+        # the errors should appear against the fields with issues
+        error_messages = soup.css.select(".error-message")
+        self.assertEqual(len(error_messages), 2)
+        error_message = error_messages[0]
+        self.assertEqual(error_message.parent["id"], "panel-child-snippet_id-errors")
+        self.assertIn("This field is required", error_message.get_text())
 
     def test_edit(self):
         response = self.post(

wagtail/snippets/views/snippets.py

@@ -444,6 +444,14 @@ class WorkflowHistoryDetailView(
     permission_required = "change"
 
 
+class ReorderView(generic.ReorderView):
+    @cached_property
+    def permission_required(self):
+        if issubclass(self.model, DraftStateMixin):
+            return "publish"
+        return super().permission_required
+
+
 class SnippetViewSet(ModelViewSet):
     """
     A viewset that instantiates the admin views for snippets.
@@ -505,6 +513,9 @@ class SnippetViewSet(ModelViewSet):
     #: The view class to use for the inspect view; must be a subclass of ``wagtail.snippets.views.snippets.InspectView``.
     inspect_view_class = InspectView
 
+    #: The view class to use for the reorder view; must be a subclass of ``wagtail.snippets.views.snippets.ReorderView``.
+    reorder_view_class = ReorderView
+
     #: The view class to use for previewing revisions; must be a subclass of ``wagtail.snippets.views.snippets.PreviewRevisionView``.
     revisions_view_class = PreviewRevisionView
 
@@ -1048,6 +1059,11 @@ class SnippetViewSet(ModelViewSet):
             ),
         ]
 
+        if self.reorder_view_enabled:
+            urlpatterns += [
+                path("reorder/<str:pk>/", self.reorder_view, name="reorder")
+            ]
+
         if self.copy_view_enabled:
             urlpatterns += [path("copy/<str:pk>/", self.copy_view, name="copy")]
 

wagtail/test/numberformat.py

@@ -4,9 +4,11 @@
 # USE_THOUSAND_SEPARATOR = True incorrectly reformats numbers that are not intended to be
 # human-readable (such as image dimensions, or IDs within data attributes).
 
+from contextlib import contextmanager
 from decimal import Decimal
 
 import django.contrib.humanize.templatetags.humanize
+import django.template.base
 import django.template.defaultfilters
 import django.templatetags.l10n
 import django.utils.numberformat
@@ -17,6 +19,34 @@ from django.utils.translation import gettext, ngettext
 
 original_numberformat = django.utils.numberformat.format
 original_intcomma = django.contrib.humanize.templatetags.humanize.intcomma
+OriginalVariableNode = django.template.base.VariableNode
+
+
+@contextmanager
+def ignore_numberformat(template_names):
+    class VariableNode(OriginalVariableNode):
+        def render(self, context):
+            template_name = context.render_context.template.origin.template_name
+            # If the template being rendered is in the list of templates to ignore,
+            # restore the original numberformat function so the template can render
+            # normally, otherwise reinforce the patch as there might be multiple
+            # templates being rendered in the lifespan of the contextmanager.
+            if template_name in template_names:
+                django.utils.numberformat.format = original_numberformat
+            else:
+                django.utils.numberformat.format = patched_numberformat
+
+            return super().render(context)
+
+    # Within the contextmanager, use a VariableNode class that conditionally
+    # enforces the numberformat patch
+    django.template.base.VariableNode = VariableNode
+
+    try:
+        yield
+    finally:
+        # Restore VariableNode to always enforce the numberformat patch
+        django.template.base.VariableNode = OriginalVariableNode
 
 
 def patched_numberformat(*args, use_l10n=None, **kwargs):

wagtail/test/settings.py

@@ -1,6 +1,7 @@
 import os
 
 from django.contrib.messages import constants as message_constants
+from django.core.exceptions import ImproperlyConfigured
 from django.utils.translation import gettext_lazy as _
 
 from wagtail.test.numberformat import patch_number_formats
@@ -151,7 +152,6 @@ INSTALLED_APPS = [
     "wagtail.test.demosite",
     "wagtail.test.snippets",
     "wagtail.test.routablepage",
-    "wagtail.test.search",
     "wagtail.test.i18n",
     "wagtail.test.streamfield_migrations",
     "wagtail.contrib.simple_translation",
@@ -229,25 +229,48 @@ else:
 
 if os.environ.get("DATABASE_ENGINE") == "django.db.backends.postgresql":
     INSTALLED_APPS.append("django.contrib.postgres")
-    WAGTAILSEARCH_BACKENDS["postgresql"] = {
-        "BACKEND": "wagtail.search.backends.database",
-        "AUTO_UPDATE": False,
-        "SEARCH_CONFIG": "english",
-    }
 
-if "ELASTICSEARCH_URL" in os.environ:
-    if os.environ.get("ELASTICSEARCH_VERSION") == "8":
-        backend = "wagtail.search.backends.elasticsearch8"
-    elif os.environ.get("ELASTICSEARCH_VERSION") == "7":
-        backend = "wagtail.search.backends.elasticsearch7"
+# Tests in wagtail.tests.test_page_search.PageSearchTests will be run against each backend defined
+# in WAGTAILSEARCH_BACKENDS. Define an additional one to test the FTS-enabled backend for the
+# currently active database.
+
+WAGTAILSEARCH_BACKENDS["database"] = {
+    "BACKEND": "wagtail.search.backends.database",
+    "AUTO_UPDATE": False,
+    "SEARCH_CONFIG": "english",
+}
 
-    WAGTAILSEARCH_BACKENDS["elasticsearch"] = {
+if "ELASTICSEARCH_URL" in os.environ:
+    # Define an 'elasticsearch' backend; along with wagtail.tests.test_page_search.PageSearchTests
+    # this is also used for the Elasticsearch-specific tests in wagtail.images.tests.test_models and
+    # wagtail.documents.tests.test_search. We also want to run these tests under Opensearch; for
+    # simplicity we use the backend name 'elasticsearch' in this case too.
+    if elasticsearch_version := os.environ.get("ELASTICSEARCH_VERSION"):
+        backend = f"wagtail.search.backends.elasticsearch{elasticsearch_version}"
+    elif opensearch_version := os.environ.get("OPENSEARCH_VERSION"):
+        backend = f"wagtail.search.backends.opensearch{opensearch_version}"
+    else:
+        raise ImproperlyConfigured(
+            "If ELASTICSEARCH_URL is defined, either ELASTICSEARCH_VERSION or OPENSEARCH_VERSION must be defined too"
+        )
+
+    elasticsearch_opts = {
         "BACKEND": backend,
         "URLS": [os.environ["ELASTICSEARCH_URL"]],
         "TIMEOUT": 10,
         "max_retries": 1,
         "AUTO_UPDATE": False,
         "INDEX_SETTINGS": {"settings": {"index": {"number_of_shards": 1}}},
+        "OPTIONS": {
+            "ca_certs": os.environ.get("ELASTICSEARCH_CA_CERTS"),
+        },
+    }
+    WAGTAILSEARCH_BACKENDS["elasticsearch"] = elasticsearch_opts
+
+    # RemovedInWagtail80Warning
+    WAGTAILSEARCH_BACKENDS["elasticsearch_with_index_option"] = {
+        **elasticsearch_opts,
+        "INDEX": "wagtailtest",  # Deprecated option
     }
 
 

wagtail/test/testapp/fields.py

@@ -0,0 +1,12 @@
+from django.db import models
+
+from wagtail.coreutils import multigetattr
+
+
+class CommentableJSONField(models.JSONField):
+    def get_block_by_content_path(self, value, path_elements):
+        try:
+            multigetattr(value, ".".join(path_elements))
+        except AttributeError:
+            return False
+        return True

wagtail/test/testapp/migrations/0056_commentablejsonpage.py

@@ -0,0 +1,50 @@
+# Generated by Django 5.2.5 on 2025-08-14 19:05
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+import wagtail.fields
+import wagtail.test.testapp.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tests", "0055_previewable_settings"),
+        ("wagtailcore", "0095_groupsitepermission"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="CommentableJSONPage",
+            fields=[
+                (
+                    "page_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="wagtailcore.page",
+                    ),
+                ),
+                (
+                    "commentable_body",
+                    wagtail.test.testapp.fields.CommentableJSONField(),
+                ),
+                ("uncommentable_body", models.JSONField()),
+                (
+                    "stream_body",
+                    wagtail.fields.StreamField(
+                        [("text", 0)],
+                        block_lookup={0: ("wagtail.blocks.CharBlock", (), {})},
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+            bases=("wagtailcore.page",),
+        ),
+    ]