wagtail 6.1.3__py3-none-any.whl → 6.2__py3-none-any.whl

wagtail/tests/streamfield_migrations/test_migrations.py

@@ -1,7 +1,8 @@
 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
@@ -24,8 +25,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 +45,9 @@ class BaseMigrationTest(TestCase, MigrationTestMixin):
             ),
         ]
 
+    def setUp(self):
+        instances = self._get_test_instances()
+
         self.original_raw_data = {}
         self.original_revisions = {}
 
@@ -102,9 +106,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 +130,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 +159,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 +207,46 @@ 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()

wagtail/tests/test_audit_log.py

@@ -3,6 +3,7 @@ import json
 
 from django.conf import settings
 from django.contrib.auth import get_user_model
+from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.core.serializers.json import DjangoJSONEncoder
 from django.test import TestCase
@@ -10,6 +11,7 @@ from django.utils import timezone
 from freezegun import freeze_time
 
 from wagtail.log_actions import LogActionRegistry
+from wagtail.log_actions import registry as log_registry
 from wagtail.models import (
     Page,
     PageLogEntry,
@@ -36,8 +38,13 @@ class TestAuditLogManager(WagtailTestUtils, TestCase):
                 title="Simple page", slug="simple", content="Hello", owner=self.user
             )
         )
+        self.snippet_1 = FullFeaturedSnippet.objects.create(text="snippet 1")
+        self.snippet_2 = FullFeaturedSnippet.objects.create(text="snippet 2")
+        self.snippet_content_type = ContentType.objects.get_for_model(
+            FullFeaturedSnippet
+        )
 
-    def test_log_action(self):
+    def test_log_action_for_page(self):
         now = timezone.now()
 
         with freeze_time(now):
@@ -49,7 +56,19 @@ class TestAuditLogManager(WagtailTestUtils, TestCase):
         self.assertEqual(entry.user, self.user)
         self.assertEqual(entry.timestamp, now)
 
-    def test_get_for_model(self):
+    def test_log_action_for_snippet(self):
+        now = timezone.now()
+
+        with freeze_time(now):
+            entry = ModelLogEntry.objects.log_action(
+                self.snippet_1, "wagtail.edit", user=self.user
+            )
+
+        self.assertEqual(entry.content_type, self.snippet_content_type)
+        self.assertEqual(entry.user, self.user)
+        self.assertEqual(entry.timestamp, now)
+
+    def test_get_for_page_model(self):
         PageLogEntry.objects.log_action(self.page, "wagtail.edit")
         PageLogEntry.objects.log_action(self.simple_page, "wagtail.edit")
 
@@ -59,11 +78,62 @@ class TestAuditLogManager(WagtailTestUtils, TestCase):
             list(entries), list(PageLogEntry.objects.filter(page=self.simple_page))
         )
 
+    def test_get_for_snippet_model(self):
+        ModelLogEntry.objects.log_action(self.snippet_1, "wagtail.edit")
+        ModelLogEntry.objects.log_action(self.snippet_2, "wagtail.edit")
+
+        entries = ModelLogEntry.objects.get_for_model(FullFeaturedSnippet)
+        self.assertEqual(entries.count(), 2)
+        self.assertListEqual(
+            list(entries),
+            list(ModelLogEntry.objects.filter(content_type=self.snippet_content_type)),
+        )
+
     def test_get_for_user(self):
         self.assertEqual(
             PageLogEntry.objects.get_for_user(self.user).count(), 1
         )  # the create from setUp
 
+    def test_get_for_page_instance(self):
+        PageLogEntry.objects.log_action(self.page, "wagtail.edit")
+        PageLogEntry.objects.log_action(self.simple_page, "wagtail.edit")
+        other_simple_page = self.page.add_child(
+            instance=SimplePage(
+                title="Simple page 2", slug="simple2", content="Hello", owner=self.user
+            )
+        )
+        PageLogEntry.objects.log_action(other_simple_page, "wagtail.edit")
+
+        entries = PageLogEntry.objects.for_instance(self.simple_page)
+        expected_entries = list(PageLogEntry.objects.filter(page=self.simple_page))
+        self.assertEqual(entries.count(), 2)
+        self.assertListEqual(list(entries), expected_entries)
+
+        # should also be able to retrieve entries via the log registry, which
+        # eliminates the need to know that PageLogEntry is the log entry model
+        entries = log_registry.get_logs_for_instance(self.simple_page)
+        self.assertEqual(entries.count(), 2)
+        self.assertListEqual(list(entries), expected_entries)
+
+    def test_get_for_snippet_instance(self):
+        ModelLogEntry.objects.log_action(self.snippet_1, "wagtail.edit")
+        ModelLogEntry.objects.log_action(self.snippet_2, "wagtail.edit")
+
+        entries = ModelLogEntry.objects.for_instance(self.snippet_1)
+        expected_entries = list(
+            ModelLogEntry.objects.filter(
+                content_type=self.snippet_content_type, object_id=self.snippet_1.pk
+            )
+        )
+        self.assertEqual(entries.count(), 1)
+        self.assertListEqual(list(entries), expected_entries)
+
+        # should also be able to retrieve entries via the log registry, which
+        # eliminates the need to know that ModelLogEntry is the log entry model
+        entries = log_registry.get_logs_for_instance(self.snippet_1)
+        self.assertEqual(entries.count(), 1)
+        self.assertListEqual(list(entries), expected_entries)
+
 
 class TestAuditLog(TestCase):
     def setUp(self):

wagtail/tests/test_blocks.py

@@ -17,6 +17,7 @@ from django.utils.translation import gettext_lazy as _
 
 from wagtail import blocks
 from wagtail.blocks.base import get_error_json_data
+from wagtail.blocks.definition_lookup import BlockDefinitionLookup
 from wagtail.blocks.field_block import FieldBlockAdapter
 from wagtail.blocks.list_block import ListBlockAdapter, ListBlockValidationError
 from wagtail.blocks.static_block import StaticBlockAdapter
@@ -5882,3 +5883,105 @@ class TestValidationErrorAsJsonData(TestCase):
                 ],
             },
         )
+
+
+class TestBlockDefinitionLookup(TestCase):
+    def test_simple_lookup(self):
+        lookup = BlockDefinitionLookup(
+            {
+                0: ("wagtail.blocks.CharBlock", [], {"required": True}),
+                1: ("wagtail.blocks.RichTextBlock", [], {}),
+            }
+        )
+        char_block = lookup.get_block(0)
+        char_block.set_name("title")
+        self.assertIsInstance(char_block, blocks.CharBlock)
+        self.assertTrue(char_block.required)
+
+        rich_text_block = lookup.get_block(1)
+        self.assertIsInstance(rich_text_block, blocks.RichTextBlock)
+
+        # A subsequent call to get_block with the same index should return a new instance;
+        # this ensures that state changes such as set_name are independent of other blocks
+        char_block_2 = lookup.get_block(0)
+        char_block_2.set_name("subtitle")
+        self.assertIsInstance(char_block, blocks.CharBlock)
+        self.assertTrue(char_block.required)
+        self.assertIsNot(char_block, char_block_2)
+        self.assertEqual(char_block.name, "title")
+        self.assertEqual(char_block_2.name, "subtitle")
+
+    def test_structblock_lookup(self):
+        lookup = BlockDefinitionLookup(
+            {
+                0: ("wagtail.blocks.CharBlock", [], {"required": True}),
+                1: ("wagtail.blocks.RichTextBlock", [], {}),
+                2: (
+                    "wagtail.blocks.StructBlock",
+                    [
+                        [
+                            ("title", 0),
+                            ("description", 1),
+                        ],
+                    ],
+                    {},
+                ),
+            }
+        )
+        struct_block = lookup.get_block(2)
+        self.assertIsInstance(struct_block, blocks.StructBlock)
+        title_block = struct_block.child_blocks["title"]
+        self.assertIsInstance(title_block, blocks.CharBlock)
+        self.assertTrue(title_block.required)
+        description_block = struct_block.child_blocks["description"]
+        self.assertIsInstance(description_block, blocks.RichTextBlock)
+
+    def test_streamblock_lookup(self):
+        lookup = BlockDefinitionLookup(
+            {
+                0: ("wagtail.blocks.CharBlock", [], {"required": True}),
+                1: ("wagtail.blocks.RichTextBlock", [], {}),
+                2: (
+                    "wagtail.blocks.StreamBlock",
+                    [
+                        [
+                            ("heading", 0),
+                            ("paragraph", 1),
+                        ],
+                    ],
+                    {},
+                ),
+            }
+        )
+        stream_block = lookup.get_block(2)
+        self.assertIsInstance(stream_block, blocks.StreamBlock)
+        title_block = stream_block.child_blocks["heading"]
+        self.assertIsInstance(title_block, blocks.CharBlock)
+        self.assertTrue(title_block.required)
+        description_block = stream_block.child_blocks["paragraph"]
+        self.assertIsInstance(description_block, blocks.RichTextBlock)
+
+    def test_listblock_lookup(self):
+        lookup = BlockDefinitionLookup(
+            {
+                0: ("wagtail.blocks.CharBlock", [], {"required": True}),
+                1: ("wagtail.blocks.ListBlock", [0], {}),
+            }
+        )
+        list_block = lookup.get_block(1)
+        self.assertIsInstance(list_block, blocks.ListBlock)
+        list_item_block = list_block.child_block
+        self.assertIsInstance(list_item_block, blocks.CharBlock)
+        self.assertTrue(list_item_block.required)
+
+        # Passing a class as the child block is still valid; this is not converted
+        # to a reference
+        lookup = BlockDefinitionLookup(
+            {
+                0: ("wagtail.blocks.ListBlock", [blocks.CharBlock], {}),
+            }
+        )
+        list_block = lookup.get_block(0)
+        self.assertIsInstance(list_block, blocks.ListBlock)
+        list_item_block = list_block.child_block
+        self.assertIsInstance(list_item_block, blocks.CharBlock)

wagtail/tests/test_signals.py

@@ -1,9 +1,10 @@
 from unittest import mock
 
+from django.conf import settings
 from django.test import TestCase
 
-from wagtail.models import Site
-from wagtail.signals import page_slug_changed
+from wagtail.models import Locale, Site
+from wagtail.signals import copy_for_translation_done, page_slug_changed
 from wagtail.test.testapp.models import SimplePage
 from wagtail.test.utils import WagtailTestUtils
 
@@ -97,3 +98,49 @@ class TestPageSlugChangedSignal(WagtailTestUtils, TestCase):
 
         # Check the signal was NOT fired
         self.assertEqual(handler.call_count, 0)
+
+
+class TestCopyForTranslationDoneSignal(WagtailTestUtils, TestCase):
+    """
+    Tests for the `wagtail.signals.copy_for_translation_done` signal
+    """
+
+    def setUp(self):
+        # Find root page
+        site = Site.objects.select_related("root_page").get(is_default_site=True)
+        root_page = site.root_page
+
+        # Create a subpage
+        self.subpage = SimplePage(
+            title="Subpage in english", slug="subpage-in-english", content="hello"
+        )
+        root_page.add_child(instance=self.subpage)
+
+        # Get the languages and create locales
+        language_codes = dict(settings.LANGUAGES).keys()
+
+        for language_code in language_codes:
+            Locale.objects.get_or_create(language_code=language_code)
+
+        # Get the locales needed
+        self.locale = Locale.objects.get(language_code="en")
+        self.another_locale = Locale.objects.get(language_code="fr")
+
+        root_page.copy_for_translation(self.another_locale)
+
+    def test_signal_emitted_on_copy_for_translation_done(self):
+        # Connect a mock signal handler to the signal
+        handler = mock.MagicMock()
+        copy_for_translation_done.connect(handler)
+
+        page_to_translate = SimplePage.objects.get(id=self.subpage.id)
+
+        try:
+            with self.captureOnCommitCallbacks(execute=True):
+                page_to_translate.copy_for_translation(self.another_locale)
+        finally:
+            # Disconnect mock handler to prevent cross-test pollution
+            copy_for_translation_done.disconnect(handler)
+
+        # Check the signal was fired
+        self.assertEqual(handler.call_count, 1)

wagtail/tests/test_streamfield.py

@@ -721,3 +721,233 @@ class TestGetBlockByContentPath(TestCase):
         self.assertEqual(bound_block.value, "Barnaby Rudge")
         bound_block = field.get_block_by_content_path(self.page.body, ["456", "999"])
         self.assertIsNone(bound_block)
+
+
+class TestConstructStreamFieldFromLookup(TestCase):
+    def test_construct_block_list_from_lookup(self):
+        field = StreamField(
+            [
+                ("heading", 0),
+                ("paragraph", 1),
+                ("button", 3),
+            ],
+            block_lookup={
+                0: ("wagtail.blocks.CharBlock", [], {"required": True}),
+                1: ("wagtail.blocks.RichTextBlock", [], {}),
+                2: ("wagtail.blocks.PageChooserBlock", [], {}),
+                3: (
+                    "wagtail.blocks.StructBlock",
+                    [
+                        [
+                            ("page", 2),
+                            ("link_text", 0),
+                        ]
+                    ],
+                    {},
+                ),
+            },
+        )
+        stream_block = field.stream_block
+        self.assertIsInstance(stream_block, blocks.StreamBlock)
+        self.assertEqual(len(stream_block.child_blocks), 3)
+
+        heading_block = stream_block.child_blocks["heading"]
+        self.assertIsInstance(heading_block, blocks.CharBlock)
+        self.assertTrue(heading_block.required)
+        self.assertEqual(heading_block.name, "heading")
+
+        paragraph_block = stream_block.child_blocks["paragraph"]
+        self.assertIsInstance(paragraph_block, blocks.RichTextBlock)
+        self.assertEqual(paragraph_block.name, "paragraph")
+
+        button_block = stream_block.child_blocks["button"]
+        self.assertIsInstance(button_block, blocks.StructBlock)
+        self.assertEqual(button_block.name, "button")
+        self.assertEqual(len(button_block.child_blocks), 2)
+        page_block = button_block.child_blocks["page"]
+        self.assertIsInstance(page_block, blocks.PageChooserBlock)
+        link_text_block = button_block.child_blocks["link_text"]
+        self.assertIsInstance(link_text_block, blocks.CharBlock)
+        self.assertEqual(link_text_block.name, "link_text")
+
+    def test_construct_top_level_block_from_lookup(self):
+        field = StreamField(
+            4,
+            block_lookup={
+                0: ("wagtail.blocks.CharBlock", [], {"required": True}),
+                1: ("wagtail.blocks.RichTextBlock", [], {}),
+                2: ("wagtail.blocks.PageChooserBlock", [], {}),
+                3: (
+                    "wagtail.blocks.StructBlock",
+                    [
+                        [
+                            ("page", 2),
+                            ("link_text", 0),
+                        ]
+                    ],
+                    {},
+                ),
+                4: (
+                    "wagtail.blocks.StreamBlock",
+                    [
+                        [
+                            ("heading", 0),
+                            ("paragraph", 1),
+                            ("button", 3),
+                        ]
+                    ],
+                    {},
+                ),
+            },
+        )
+        stream_block = field.stream_block
+        self.assertIsInstance(stream_block, blocks.StreamBlock)
+        self.assertEqual(len(stream_block.child_blocks), 3)
+
+        heading_block = stream_block.child_blocks["heading"]
+        self.assertIsInstance(heading_block, blocks.CharBlock)
+        self.assertTrue(heading_block.required)
+        self.assertEqual(heading_block.name, "heading")
+
+        paragraph_block = stream_block.child_blocks["paragraph"]
+        self.assertIsInstance(paragraph_block, blocks.RichTextBlock)
+        self.assertEqual(paragraph_block.name, "paragraph")
+
+        button_block = stream_block.child_blocks["button"]
+        self.assertIsInstance(button_block, blocks.StructBlock)
+        self.assertEqual(button_block.name, "button")
+        self.assertEqual(len(button_block.child_blocks), 2)
+        page_block = button_block.child_blocks["page"]
+        self.assertIsInstance(page_block, blocks.PageChooserBlock)
+        link_text_block = button_block.child_blocks["link_text"]
+        self.assertIsInstance(link_text_block, blocks.CharBlock)
+        self.assertEqual(link_text_block.name, "link_text")
+
+
+# Used by TestDeconstructStreamFieldWithLookup.test_deconstruct_with_listblock_subclass -
+# needs to be a module-level definition so that the path returned from deconstruct is valid
+class BulletListBlock(blocks.ListBlock):
+    def __init__(self, **kwargs):
+        super().__init__(blocks.CharBlock(required=True), **kwargs)
+
+
+class TestDeconstructStreamFieldWithLookup(TestCase):
+    def test_deconstruct(self):
+        class ButtonBlock(blocks.StructBlock):
+            page = blocks.PageChooserBlock()
+            link_text = blocks.CharBlock(required=True)
+
+        field = StreamField(
+            [
+                ("heading", blocks.CharBlock(required=True)),
+                ("paragraph", blocks.RichTextBlock()),
+                ("button", ButtonBlock()),
+            ],
+            blank=True,
+        )
+        field.set_attributes_from_name("body")
+
+        name, path, args, kwargs = field.deconstruct()
+        self.assertEqual(name, "body")
+        self.assertEqual(path, "wagtail.fields.StreamField")
+        self.assertEqual(
+            args,
+            [
+                [
+                    ("heading", 0),
+                    ("paragraph", 1),
+                    ("button", 3),
+                ]
+            ],
+        )
+        self.assertEqual(
+            kwargs,
+            {
+                "blank": True,
+                "block_lookup": {
+                    0: ("wagtail.blocks.CharBlock", (), {"required": True}),
+                    1: ("wagtail.blocks.RichTextBlock", (), {}),
+                    2: ("wagtail.blocks.PageChooserBlock", (), {}),
+                    3: (
+                        "wagtail.blocks.StructBlock",
+                        [
+                            [
+                                ("page", 2),
+                                ("link_text", 0),
+                            ]
+                        ],
+                        {},
+                    ),
+                },
+            },
+        )
+
+    def test_deconstruct_with_listblock(self):
+        field = StreamField(
+            [
+                ("heading", blocks.CharBlock(required=True)),
+                ("bullets", blocks.ListBlock(blocks.CharBlock(required=True))),
+            ],
+            blank=True,
+        )
+        field.set_attributes_from_name("body")
+        name, path, args, kwargs = field.deconstruct()
+        self.assertEqual(name, "body")
+        self.assertEqual(path, "wagtail.fields.StreamField")
+        self.assertEqual(
+            args,
+            [
+                [
+                    ("heading", 0),
+                    ("bullets", 1),
+                ]
+            ],
+        )
+        self.assertEqual(
+            kwargs,
+            {
+                "blank": True,
+                "block_lookup": {
+                    0: ("wagtail.blocks.CharBlock", (), {"required": True}),
+                    1: ("wagtail.blocks.ListBlock", (0,), {}),
+                },
+            },
+        )
+
+    def test_deconstruct_with_listblock_subclass(self):
+        # See https://github.com/wagtail/wagtail/issues/12164 - unlike StructBlock and StreamBlock,
+        # ListBlock's deconstruct method doesn't reduce subclasses to the base ListBlock class.
+        # Therefore, if a ListBlock subclass defines its own __init__ method with an incompatible
+        # signature to the base ListBlock, this custom signature will be preserved in the result of
+        # deconstruct(), and we cannot rely on the first argument being the child block.
+
+        field = StreamField(
+            [
+                ("heading", blocks.CharBlock(required=True)),
+                ("bullets", BulletListBlock()),
+            ],
+            blank=True,
+        )
+        field.set_attributes_from_name("body")
+        name, path, args, kwargs = field.deconstruct()
+        self.assertEqual(name, "body")
+        self.assertEqual(path, "wagtail.fields.StreamField")
+        self.assertEqual(
+            args,
+            [
+                [
+                    ("heading", 0),
+                    ("bullets", 1),
+                ]
+            ],
+        )
+        self.assertEqual(
+            kwargs,
+            {
+                "blank": True,
+                "block_lookup": {
+                    0: ("wagtail.blocks.CharBlock", (), {"required": True}),
+                    1: ("wagtail.tests.test_streamfield.BulletListBlock", (), {}),
+                },
+            },
+        )

wagtail/tests/test_utils.py

@@ -29,6 +29,7 @@ from wagtail.coreutils import (
 from wagtail.models import Page, Site
 from wagtail.utils.file import hash_filelike
 from wagtail.utils.utils import deep_update, flatten_choices
+from wagtail.utils.version import get_main_version
 
 
 class TestCamelCaseToUnderscore(TestCase):
@@ -577,6 +578,19 @@ class HashFileLikeTestCase(SimpleTestCase):
         )
 
 
+class TestVersion(SimpleTestCase):
+    def test_get_main_version(self):
+        cases = [
+            ((6, 2, 0, "final", 0), False, "6.2"),
+            ((6, 2, 1, "final", 0), False, "6.2"),
+            ((6, 2, 0, "final", 0), True, "6.2"),
+            ((6, 2, 1, "final", 0), True, "6.2.1"),
+        ]
+        for version, include_patch, expected in cases:
+            with self.subTest(version=version, include_patch=include_patch):
+                self.assertEqual(get_main_version(version, include_patch), expected)
+
+
 class TestFlattenChoices(SimpleTestCase):
     def test_tuple_choices(self):
         choices = [(1, "1st"), (2, "2nd")]

wagtail/tests/tests.py

@@ -9,6 +9,7 @@ from django.test import TestCase
 from django.test.utils import override_settings
 from django.urls.exceptions import NoReverseMatch
 from django.utils.safestring import SafeString
+from django.utils.translation import gettext_lazy
 
 from wagtail.coreutils import (
     get_dummy_request,
@@ -536,6 +537,10 @@ class TestRichtextTag(TestCase):
         self.assertEqual(result, "Hello world!")
         self.assertIsInstance(result, SafeString)
 
+    def test_call_with_lazy(self):
+        result = richtext(gettext_lazy("test"))
+        self.assertEqual(result, "test")
+
     def test_call_with_none(self):
         result = richtext(None)
         self.assertEqual(result, "")

wagtail/users/apps.py

@@ -8,3 +8,4 @@ class WagtailUsersAppConfig(AppConfig):
     verbose_name = _("Wagtail users")
     default_auto_field = "django.db.models.AutoField"
     group_viewset = "wagtail.users.views.groups.GroupViewSet"
+    user_viewset = "wagtail.users.views.users.UserViewSet"