wagtail 5.2.6__py3-none-any.whl → 5.2.8__py3-none-any.whl

wagtail/admin/tests/test_workflows.py

@@ -135,6 +135,33 @@ class TestWorkflowsIndexView(AdminTemplateTestUtils, WagtailTestUtils, TestCase)
         self.assertNotContains(response, "There are no enabled workflows.")
         self.assertContains(response, "test_workflow")
 
+    def test_multiple_snippets_assigned_to_workflow(self):
+        Workflow.objects.create(name="Nocontenttypes")
+        multi_ct_workflow = Workflow.objects.create(name="Multicontenttypes")
+        for model in [FullFeaturedSnippet, ModeratedModel]:
+            WorkflowContentType.objects.create(
+                workflow=multi_ct_workflow,
+                content_type=ContentType.objects.get_for_model(model),
+            )
+
+        response = self.get()
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        cells = [
+            text
+            for td in soup.select("td")
+            if (text := td.get_text(separator=" | ", strip=True))
+        ]
+        self.assertEqual(
+            cells,
+            [
+                "Multicontenttypes",
+                "0 pages | 2 snippet types",
+                "Nocontenttypes",
+                "0 pages | 0 snippet types",
+            ],
+        )
+
     def test_deactivated(self):
         Workflow.objects.create(name="test_workflow", active=False)
 

wagtail/admin/views/workflows.py

@@ -2,7 +2,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import PermissionDenied
 from django.core.paginator import Paginator
 from django.db import transaction
-from django.db.models import Count, OuterRef
+from django.db.models import Count
 from django.db.models.functions import Lower
 from django.http import Http404, HttpResponseBadRequest
 from django.shortcuts import get_object_or_404, redirect, render
@@ -34,7 +34,6 @@ from wagtail.models import (
     Task,
     TaskState,
     Workflow,
-    WorkflowContentType,
     WorkflowState,
 )
 from wagtail.permission_policies.pages import PagePermissionPolicy
@@ -64,10 +63,7 @@ class Index(IndexView):
         queryset = super().get_queryset()
         if not self.show_disabled():
             queryset = queryset.filter(active=True)
-        content_types = WorkflowContentType.objects.filter(
-            workflow=OuterRef("pk")
-        ).values_list("pk", flat=True)
-        queryset = queryset.annotate(content_types=Count(content_types))
+        queryset = queryset.annotate(content_types=Count("workflow_content_types"))
         return queryset
 
     def get_context_data(self, **kwargs):

wagtail/blocks/migrations/migrate_operation.py

@@ -110,6 +110,8 @@ class MigrateStreamData(RunPython):
 
         updated_model_instances_buffer = []
         for instance in model_queryset.iterator(chunk_size=self.chunk_size):
+            if instance.raw_content is None:
+                continue
 
             revision_query_maker.append_instance_data_for_revision_query(instance)
 

wagtail/blocks/migrations/operations.py

@@ -153,29 +153,29 @@ class StreamChildrenToListBlockOperation(BaseBlockOperation):
         super().__init__()
         self.block_name = block_name
         self.list_block_name = list_block_name
-        self.temp_blocks = []
 
     def apply(self, block_value):
+        candidate_blocks = []
         mapped_block_value = []
         for child_block in block_value:
             if child_block["type"] == self.block_name:
-                self.temp_blocks.append(child_block)
+                candidate_blocks.append(child_block)
             else:
                 mapped_block_value.append(child_block)
 
-        self.map_temp_blocks_to_list_items()
+        list_items = self.map_temp_blocks_to_list_items(candidate_blocks)
 
-        if self.temp_blocks:
-            new_list_block = {"type": self.list_block_name, "value": self.temp_blocks}
+        if list_items:
+            new_list_block = {"type": self.list_block_name, "value": list_items}
             mapped_block_value.append(new_list_block)
 
         return mapped_block_value
 
-    def map_temp_blocks_to_list_items(self):
-        new_temp_blocks = []
-        for block in self.temp_blocks:
-            new_temp_blocks.append({**block, "type": "item"})
-        self.temp_blocks = new_temp_blocks
+    def map_temp_blocks_to_list_items(self, blocks):
+        list_items = []
+        for block in blocks:
+            list_items.append({**block, "type": "item"})
+        return list_items
 
     @property
     def operation_name_fragment(self):

wagtail/blocks/stream_block.py

@@ -653,7 +653,7 @@ class StreamValue(MutableSequence):
         raw_values = OrderedDict(
             (i, raw_item["value"])
             for i, raw_item in enumerate(self._raw_data)
-            if raw_item["type"] == type_name and self._bound_blocks[i] is None
+            if self._bound_blocks[i] is None and raw_item["type"] == type_name
         )
         # pass the raw block values to bulk_to_python as a list
         converted_values = child_block.bulk_to_python(raw_values.values())

wagtail/contrib/forms/tests/test_models.py

@@ -611,11 +611,13 @@ class TestFormPageWithCustomFormBuilder(WagtailTestUtils, TestCase):
             html=True,
         )
         # check ip address field has rendered
-        self.assertContains(
-            response,
-            '<input type="text" name="device_ip_address" required id="id_device_ip_address" />',
-            html=True,
-        )
+        # (not comparing HTML directly because https://docs.djangoproject.com/en/5.1/releases/5.1.5/
+        # added a maxlength attribute)
+        soup = self.get_soup(response.content)
+        input = soup.find("input", {"name": "device_ip_address"})
+        self.assertEqual(input["type"], "text")
+        self.assertEqual(input["required"], "")
+        self.assertEqual(input["id"], "id_device_ip_address")
 
     def test_post_invalid_form(self):
         response = self.client.post(

wagtail/search/backends/database/mysql/mysql.py

@@ -1,3 +1,4 @@
+import re
 import warnings
 from collections import OrderedDict
 
@@ -336,9 +337,12 @@ class MySQLSearchQueryCompiler(BaseSearchQueryCompiler):
 
     def build_search_query_content(self, query, invert=False):
         if isinstance(query, PlainText):
-            terms = query.query_string.split()
+            # For Boolean full text search queries in MySQL,
+            # non-alphanumeric characters act as separators
+            terms = [term for term in re.split(r"\W+", query.query_string) if term]
+
             if not terms:
-                return None
+                return SearchQuery("")
 
             last_term = terms.pop()
 

wagtail/search/tests/test_mysql_backend.py

@@ -68,6 +68,81 @@ class TestMySQLSearchBackend(BackendTests, TransactionTestCase):
             all_other_titles | {"JavaScript: The Definitive Guide"},
         )
 
+    def test_empty_search(self):
+        results = self.backend.search("", models.Book.objects.all())
+        self.assertSetEqual(
+            {r.title for r in results},
+            set(),
+        )
+
+        results = self.backend.search(" ", models.Book.objects.all())
+        self.assertSetEqual(
+            {r.title for r in results},
+            set(),
+        )
+
+        results = self.backend.search("*", models.Book.objects.all())
+        self.assertSetEqual(
+            {r.title for r in results},
+            set(),
+        )
+
+    def test_empty_autocomplete(self):
+        results = self.backend.autocomplete("", models.Book.objects.all())
+        self.assertSetEqual(
+            {r.title for r in results},
+            set(),
+        )
+
+        results = self.backend.autocomplete(" ", models.Book.objects.all())
+        self.assertSetEqual(
+            {r.title for r in results},
+            set(),
+        )
+
+        results = self.backend.autocomplete("*", models.Book.objects.all())
+        self.assertSetEqual(
+            {r.title for r in results},
+            set(),
+        )
+
+    def test_symbols_in_search_term(self):
+        # symbols as their own tokens should be ignored
+        results = self.backend.search("javascript @ parts", models.Book.objects.all())
+        self.assertSetEqual(
+            {r.title for r in results},
+            {"JavaScript: The good parts"},
+        )
+
+        results = self.backend.search("javascript parts @", models.Book.objects.all())
+        self.assertSetEqual(
+            {r.title for r in results},
+            {"JavaScript: The good parts"},
+        )
+
+        results = self.backend.search("@ javascript parts", models.Book.objects.all())
+        self.assertSetEqual(
+            {r.title for r in results},
+            {"JavaScript: The good parts"},
+        )
+
+        # tokens containing both symbols and alphanumerics should not be discarded
+        # or treated as equivalent to the same token without symbols
+        results = self.backend.search("java@script parts", models.Book.objects.all())
+        self.assertSetEqual(
+            {r.title for r in results},
+            set(),
+        )
+
+    def test_autocomplete_with_symbols(self):
+        # the * is not part of the autocomplete mechanism, but if someone includes it
+        # we want it to be gracefully ignored
+        results = self.backend.autocomplete("parts javasc*", models.Book.objects.all())
+        self.assertSetEqual(
+            {r.title for r in results},
+            {"JavaScript: The good parts"},
+        )
+
     @skip(
         "The MySQL backend doesn't support choosing individual fields for the search, only (body, title) or (autocomplete) fields may be searched."
     )

wagtail/test/snippets/apps.py

@@ -7,3 +7,13 @@ class WagtailSnippetsTestsAppConfig(AppConfig):
     name = "wagtail.test.snippets"
     label = "snippetstests"
     verbose_name = _("Wagtail snippets tests")
+
+    def ready(self):
+        # Test registration of permission order within the group permissions view,
+        # as per https://docs.wagtail.org/en/stable/extending/customizing_group_views.html#customizing-the-group-editor-permissions-ordering
+        # Invoking `register` from `ready` confirms that it does not perform any database queries -
+        # if it did, it would fail (on a standard test run without --keepdb at least) because the
+        # test database hasn't been migrated yet.
+        from wagtail.users.permission_order import register
+
+        register("snippetstests.fancysnippet", order=999)

wagtail/test/streamfield_migrations/testutils.py

@@ -10,7 +10,7 @@ class MigrationTestMixin:
     default_operation_and_block_path = []
     app_name = None
 
-    def init_migration(self, revisions_from=None, operations_and_block_path=None):
+    def init_migration(self, revisions_from=None, operations_and_block_paths=None):
         migration = Migration(
             "test_migration", "wagtail_streamfield_migration_toolkit_test"
         )
@@ -18,7 +18,7 @@ class MigrationTestMixin:
             app_name=self.app_name,
             model_name=self.model.__name__,
             field_name="content",
-            operations_and_block_paths=operations_and_block_path
+            operations_and_block_paths=operations_and_block_paths
             or self.default_operation_and_block_path,
             revisions_from=revisions_from,
         )
@@ -29,11 +29,11 @@ class MigrationTestMixin:
     def apply_migration(
         self,
         revisions_from=None,
-        operations_and_block_path=None,
+        operations_and_block_paths=None,
     ):
         migration = self.init_migration(
             revisions_from=revisions_from,
-            operations_and_block_path=operations_and_block_path,
+            operations_and_block_paths=operations_and_block_paths,
         )
 
         loader = MigrationLoader(connection=connection)

wagtail/tests/streamfield_migrations/test_migration_names.py

@@ -13,35 +13,35 @@ class MigrationNameTest(TestCase, MigrationTestMixin):
     app_name = "wagtail_streamfield_migration_toolkit_test"
 
     def test_rename(self):
-        operations_and_block_path = [
+        operations_and_block_paths = [
             (
                 RenameStreamChildrenOperation(old_name="char1", new_name="renamed1"),
                 "",
             )
         ]
         migration = self.init_migration(
-            operations_and_block_path=operations_and_block_path
+            operations_and_block_paths=operations_and_block_paths
         )
 
         suggested_name = migration.suggest_name()
         self.assertEqual(suggested_name, "rename_char1_to_renamed1")
 
     def test_remove(self):
-        operations_and_block_path = [
+        operations_and_block_paths = [
             (
                 RemoveStreamChildrenOperation(name="char1"),
                 "",
             )
         ]
         migration = self.init_migration(
-            operations_and_block_path=operations_and_block_path
+            operations_and_block_paths=operations_and_block_paths
         )
 
         suggested_name = migration.suggest_name()
         self.assertEqual(suggested_name, "remove_char1")
 
     def test_multiple(self):
-        operations_and_block_path = [
+        operations_and_block_paths = [
             (
                 RenameStreamChildrenOperation(old_name="char1", new_name="renamed1"),
                 "",
@@ -52,7 +52,7 @@ class MigrationNameTest(TestCase, MigrationTestMixin):
             ),
         ]
         migration = self.init_migration(
-            operations_and_block_path=operations_and_block_path
+            operations_and_block_paths=operations_and_block_paths
         )
 
         suggested_name = migration.suggest_name()

wagtail/tests/streamfield_migrations/test_migrations.py

@@ -1,12 +1,16 @@
 import datetime
 import json
 
-from django.db.models import F, JSONField
+from django.db import connection
+from django.db.models import F, JSONField, TextField
 from django.db.models.functions import Cast
 from django.test import TestCase
 from django.utils import timezone
 
-from wagtail.blocks.migrations.operations import RenameStreamChildrenOperation
+from wagtail.blocks.migrations.operations import (
+    RenameStreamChildrenOperation,
+    StreamChildrenToListBlockOperation,
+)
 from wagtail.test.streamfield_migrations import factories, models
 from wagtail.test.streamfield_migrations.testutils import MigrationTestMixin
 
@@ -24,8 +28,8 @@ class BaseMigrationTest(TestCase, MigrationTestMixin):
     ]
     app_name = None
 
-    def setUp(self):
-        instances = [
+    def _get_test_instances(self):
+        return [
             self.factory(
                 content__0__char1="Test char 1",
                 content__1__char1="Test char 2",
@@ -44,6 +48,9 @@ class BaseMigrationTest(TestCase, MigrationTestMixin):
             ),
         ]
 
+    def setUp(self):
+        instances = self._get_test_instances()
+
         self.original_raw_data = {}
         self.original_revisions = {}
 
@@ -102,9 +109,7 @@ class BaseMigrationTest(TestCase, MigrationTestMixin):
 
         self.apply_migration()
 
-        instances = self.model.objects.all().annotate(
-            raw_content=Cast(F("content"), JSONField())
-        )
+        instances = self.model.objects.all()
 
         for instance in instances:
             old_revisions = self.original_revisions[instance.id]
@@ -128,9 +133,7 @@ class BaseMigrationTest(TestCase, MigrationTestMixin):
         revisions_from = timezone.now() + datetime.timedelta(days=2)
         self.apply_migration(revisions_from=revisions_from)
 
-        instances = self.model.objects.all().annotate(
-            raw_content=Cast(F("content"), JSONField())
-        )
+        instances = self.model.objects.all()
 
         for instance in instances:
             old_revisions = self.original_revisions[instance.id]
@@ -159,9 +162,7 @@ class BaseMigrationTest(TestCase, MigrationTestMixin):
         revisions_from = timezone.now() - datetime.timedelta(days=2)
         self.apply_migration(revisions_from=revisions_from)
 
-        instances = self.model.objects.all().annotate(
-            raw_content=Cast(F("content"), JSONField())
-        )
+        instances = self.model.objects.all()
 
         for instance in instances:
             old_revisions = self.original_revisions[instance.id]
@@ -209,3 +210,88 @@ class TestPage(BaseMigrationTest):
 
     def test_migrate_revisions_from_date(self):
         self._test_migrate_revisions_from_date()
+
+
+class TestNullStreamField(BaseMigrationTest):
+    """
+    Migrations are processed if the underlying JSON is null.
+
+    This might occur if we're operating on a StreamField that was added to a model that
+    had existing records.
+    """
+
+    model = models.SamplePage
+    factory = factories.SamplePageFactory
+    has_revisions = True
+    app_name = "streamfield_migration_tests"
+
+    def _get_test_instances(self):
+        return self.factory.create_batch(1, content=None)
+
+    def setUp(self):
+        super().setUp()
+
+        # Bypass StreamField/StreamBlock processing that cast a None stream field value
+        # to the empty StreamValue, and set the underlying JSON to null.
+        with connection.cursor() as cursor:
+            cursor.execute(f"UPDATE {self.model._meta.db_table} SET content = 'null'")
+
+    def assert_null_content(self):
+        """
+        The raw JSON of all instances for this test is null.
+        """
+
+        instances = self.model.objects.all().annotate(
+            raw_content=Cast(F("content"), TextField())
+        )
+
+        for instance in instances:
+            with self.subTest(instance=instance):
+                self.assertEqual(instance.raw_content, "null")
+
+    def test_migrate_stream_data(self):
+        self.assert_null_content()
+        self.apply_migration()
+        self.assert_null_content()
+
+
+class StreamChildrenToListBlockOperationTestCase(BaseMigrationTest):
+    model = models.SamplePage
+    factory = factories.SamplePageFactory
+    has_revisions = True
+    app_name = "streamfield_migration_tests"
+
+    def _get_test_instances(self):
+        return self.factory.create_batch(
+            size=3,
+            # Each content stream field has a single char block instance.
+            content__0__char1__value="Char Block 1",
+        )
+
+    def test_state_not_shared_across_instances(self):
+        """
+        StreamChildrenToListBlockOperation doesn't share state across model instances.
+
+        As a single operation instance is used to transform the data of multiple model
+        instances, we should not store model instance state on the operation instance.
+        See https://github.com/wagtail/wagtail/issues/12391.
+        """
+
+        self.apply_migration(
+            operations_and_block_paths=[
+                (
+                    StreamChildrenToListBlockOperation(
+                        block_name="char1", list_block_name="list1"
+                    ),
+                    "",
+                )
+            ]
+        )
+        for instance in self.model.objects.all().annotate(
+            raw_content=Cast(F("content"), JSONField())
+        ):
+            new_block = instance.raw_content[0]
+            self.assertEqual(new_block["type"], "list1")
+            self.assertEqual(len(new_block["value"]), 1)
+            self.assertEqual(new_block["value"][0]["type"], "item")
+            self.assertEqual(new_block["value"][0]["value"], "Char Block 1")

wagtail/tests/test_streamfield.py

@@ -237,6 +237,24 @@ class TestStreamValueAccess(TestCase):
         self.assertEqual(fetched_body[1].block_type, "text")
         self.assertEqual(fetched_body[1].value, "bar")
 
+    def test_can_append_on_queried_instance(self):
+        # The test is analog to test_can_append(), but instead of working with the
+        # in-memory version from JSONStreamModel.objects.create(), we query a fresh
+        # instance from the db.
+        # It tests adding data to child blocks that
+        # have not yet been lazy loaded. This would previously crash.
+        self.json_body = JSONStreamModel.objects.get(pk=self.json_body.pk)
+        self.json_body.body.append(("text", "bar"))
+        self.json_body.save()
+
+        fetched_body = JSONStreamModel.objects.get(id=self.json_body.id).body
+        self.assertIsInstance(fetched_body, StreamValue)
+        self.assertEqual(len(fetched_body), 2)
+        self.assertEqual(fetched_body[0].block_type, "text")
+        self.assertEqual(fetched_body[0].value, "foo")
+        self.assertEqual(fetched_body[1].block_type, "text")
+        self.assertEqual(fetched_body[1].value, "bar")
+
 
 class TestStreamFieldRenderingBase(TestCase):
     model = JSONStreamModel

wagtail/users/permission_order.py

@@ -2,6 +2,7 @@ from django.contrib.contenttypes.models import ContentType
 
 from wagtail.coreutils import resolve_model_string
 
+content_types_to_register = []
 CONTENT_TYPE_ORDER = {}
 
 
@@ -13,5 +14,18 @@ def register(model, **kwargs):
     """
     order = kwargs.pop("order", None)
     if order is not None:
-        content_type = ContentType.objects.get_for_model(resolve_model_string(model))
-        CONTENT_TYPE_ORDER[content_type.id] = order
+        # We typically call this at application startup, when the database may not be ready,
+        # and so we can't look up the content type yet. Instead we will queue up the
+        # (model, order) pair to be processed when the lookup is requested.
+        content_types_to_register.append((model, order))
+
+
+def get_content_type_order_lookup():
+    if content_types_to_register:
+        for model, order in content_types_to_register:
+            content_type = ContentType.objects.get_for_model(
+                resolve_model_string(model)
+            )
+            CONTENT_TYPE_ORDER[content_type.id] = order
+        content_types_to_register.clear()
+    return CONTENT_TYPE_ORDER

wagtail/users/templatetags/wagtailusers_tags.py

@@ -4,7 +4,7 @@ import re
 from django import template
 
 from wagtail import hooks
-from wagtail.users.permission_order import CONTENT_TYPE_ORDER
+from wagtail.users.permission_order import get_content_type_order_lookup
 
 register = template.Library()
 
@@ -42,9 +42,10 @@ def format_permissions(permission_bound_field):
     # get a distinct and ordered list of the content types that these permissions relate to.
     # relies on Permission model default ordering, dict.fromkeys() retaining that order
     # from the queryset, and the stability of sorted().
+    content_type_order = get_content_type_order_lookup()
     content_type_ids = sorted(
         dict.fromkeys(permissions.values_list("content_type_id", flat=True)),
-        key=lambda ct: CONTENT_TYPE_ORDER.get(ct, float("inf")),
+        key=lambda ct: content_type_order.get(ct, float("inf")),
     )
 
     # iterate over permission_bound_field to build a lookup of individual renderable

{wagtail-5.2.6.dist-info → wagtail-5.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wagtail
-Version: 5.2.6
+Version: 5.2.8
 Summary: A Django content management system.
 Home-page: https://wagtail.org/
 Author: Wagtail core team + contributors