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

wagtail/tests/test_blocks.py

@@ -50,6 +50,13 @@ class ContextCharBlock(blocks.CharBlock):
         return super(blocks.CharBlock, self).get_context(value, parent_context)
 
 
+class TestBlock(SimpleTestCase):
+    def test_normalize(self):
+        """The base normalize implementation should return its argument unchanged"""
+        obj = object()
+        self.assertIs(blocks.Block().normalize(obj), obj)
+
+
 class TestFieldBlock(WagtailTestUtils, SimpleTestCase):
     def test_charfield_render(self):
         block = blocks.CharBlock()
@@ -206,7 +213,8 @@ class TestFieldBlock(WagtailTestUtils, SimpleTestCase):
     def test_form_handling_is_independent_of_serialisation(self):
         class Base64EncodingCharBlock(blocks.CharBlock):
             """A CharBlock with a deliberately perverse JSON (de)serialisation format
-            so that it visibly blows up if we call to_python / get_prep_value where we shouldn't"""
+            so that it visibly blows up if we call to_python / get_prep_value where we shouldn't
+            """
 
             def to_python(self, jsonish_value):
                 # decode as base64 on the way out of the JSON serialisation
@@ -718,6 +726,14 @@ class TestRichTextBlock(TestCase):
 
         self.assertEqual(list(block.extract_references(value)), [(Page, "1", "", "")])
 
+    def test_normalize(self):
+        block = blocks.RichTextBlock()
+        for value in ("Hello, world", RichText("Hello, world")):
+            with self.subTest(value=value):
+                normalized = block.normalize(value)
+                self.assertIsInstance(normalized, RichText)
+                self.assertEqual(normalized.source, "Hello, world")
+
 
 class TestChoiceBlock(WagtailTestUtils, SimpleTestCase):
     def setUp(self):
@@ -2256,6 +2272,53 @@ class TestStructBlock(SimpleTestCase):
         self.assertIs(value.block, copied.block)
         self.assertEqual(value, copied)
 
+    def test_normalize_base_cases(self):
+        """Test the trivially recursive and already normalized cases"""
+        block = blocks.StructBlock([("title", blocks.CharBlock())])
+        self.assertEqual(
+            block.normalize({"title": "Foo"}), block._to_struct_value({"title": "Foo"})
+        )
+        self.assertEqual(
+            block.normalize(block._to_struct_value({"title": "Foo"})),
+            block._to_struct_value({"title": "Foo"}),
+        )
+
+    def test_recursive_normalize(self):
+        """StructBlock.normalize should recursively normalize all children"""
+
+        block = blocks.StructBlock(
+            [
+                (
+                    "inner_stream",
+                    blocks.StreamBlock(
+                        [
+                            ("inner_char", blocks.CharBlock()),
+                            ("inner_int", blocks.IntegerBlock()),
+                        ]
+                    ),
+                ),
+                ("list_of_ints", blocks.ListBlock(blocks.IntegerBlock())),
+            ]
+        )
+
+        # A value in the human friendly format
+        value = {
+            "inner_stream": [("inner_char", "Hello, world"), ("inner_int", 42)],
+            "list_of_ints": [5, 6, 7, 8],
+        }
+
+        normalized = block.normalize(value)
+        self.assertIsInstance(normalized, blocks.StructValue)
+        self.assertIsInstance(normalized["inner_stream"], blocks.StreamValue)
+        self.assertIsInstance(
+            normalized["inner_stream"][0], blocks.StreamValue.StreamChild
+        )
+        self.assertIsInstance(
+            normalized["inner_stream"][1], blocks.StreamValue.StreamChild
+        )
+        self.assertIsInstance(normalized["list_of_ints"], blocks.list_block.ListValue)
+        self.assertIsInstance(normalized["list_of_ints"][0], int)
+
 
 class TestStructBlockWithCustomStructValue(SimpleTestCase):
     def test_initialisation(self):
@@ -2433,8 +2496,50 @@ class TestStructBlockWithCustomStructValue(SimpleTestCase):
         html = block.render(struct_value)
         self.assertEqual(html, "<div>EMPTY TITLE</div>\n")
 
+    def test_normalize(self):
+        """A normalized StructBlock value should be an instance of the StructBlock's value_class"""
+
+        class CustomStructValue(blocks.StructValue):
+            pass
+
+        class CustomStructBlock(blocks.StructBlock):
+            text = blocks.TextBlock()
+
+            class Meta:
+                value_class = CustomStructValue
+
+        self.assertIsInstance(
+            CustomStructBlock().normalize({"text": "She sells sea shells"}),
+            CustomStructValue,
+        )
+
+    def test_normalize_incorrect_value_class(self):
+        """
+        If StructBlock.normalize is passed a StructValue instance that doesn't
+        match the StructBlock's `value_class', it should convert the value
+        to the correct class.
+        """
+
+        class CustomStructValue(blocks.StructValue):
+            pass
+
+        class CustomStructBlock(blocks.StructBlock):
+            text = blocks.TextBlock()
+
+            class Meta:
+                value_class = CustomStructValue
+
+        block = CustomStructBlock()
+        # Not an instance of CustomStructValue, which CustomStructBlock uses.
+        value = blocks.StructValue(block, {"text": "The quick brown fox"})
+        self.assertIsInstance(block.normalize(value), CustomStructValue)
+
 
 class TestListBlock(WagtailTestUtils, SimpleTestCase):
+    def assert_eq_list_values(self, p, q):
+        # We can't directly compare ListValue instances yet
+        self.assertEqual(list(p), list(q))
+
     def test_initialise_with_class(self):
         block = blocks.ListBlock(blocks.CharBlock)
 
@@ -2961,6 +3066,42 @@ class TestListBlock(WagtailTestUtils, SimpleTestCase):
         self.assertEqual(len(result[0]["value"]), 2)
         self.assertEqual(result[0]["value"][0]["value"], "foo")
 
+    def test_normalize_base_case(self):
+        """Test normalize when trivially recursive, or already a ListValue"""
+        block = blocks.ListBlock(blocks.IntegerBlock)
+        normalized = block.normalize([0, 1, 1, 2, 3])
+        self.assertIsInstance(normalized, blocks.list_block.ListValue)
+        self.assert_eq_list_values(normalized, [0, 1, 1, 2, 3])
+
+        normalized = block.normalize(
+            blocks.list_block.ListValue(block, [0, 1, 1, 2, 3])
+        )
+        self.assertIsInstance(normalized, blocks.list_block.ListValue)
+        self.assert_eq_list_values(normalized, [0, 1, 1, 2, 3])
+
+    def test_normalize_empty(self):
+        block = blocks.ListBlock(blocks.IntegerBlock())
+        normalized = block.normalize([])
+        self.assertIsInstance(normalized, blocks.list_block.ListValue)
+        self.assert_eq_list_values(normalized, [])
+
+    def test_recursive_normalize(self):
+        """
+        ListBlock.normalize should recursively normalize all values passed to
+        it, and return a ListValue.
+        """
+        inner_list_block = blocks.ListBlock(blocks.IntegerBlock())
+        block = blocks.ListBlock(inner_list_block)
+        values = [
+            [[1, 2, 3]],
+            [blocks.list_block.ListValue(block, [1, 2, 3])],
+        ]
+
+        for value in values:
+            normalized = block.normalize(value)
+            self.assertIsInstance(normalized, blocks.list_block.ListValue)
+            self.assert_eq_list_values(normalized[0], [1, 2, 3])
+
 
 class TestListBlockWithFixtures(TestCase):
     fixtures = ["test.json"]
@@ -4228,6 +4369,120 @@ class TestStreamBlock(WagtailTestUtils, SimpleTestCase):
         )
 
 
+class TestNormalizeStreamBlock(SimpleTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.simple_block = blocks.StreamBlock(
+            [("number", blocks.IntegerBlock()), ("text", blocks.TextBlock())]
+        )
+        cls.recursive_block = blocks.StreamBlock(
+            [
+                (
+                    "inner_stream",
+                    blocks.StreamBlock(
+                        [
+                            ("number", blocks.IntegerBlock()),
+                            ("text", blocks.TextBlock()),
+                            ("inner_list", blocks.ListBlock(blocks.IntegerBlock)),
+                        ]
+                    ),
+                ),
+                ("struct", blocks.StructBlock([("bool", blocks.BooleanBlock())])),
+                ("list", blocks.ListBlock(blocks.IntegerBlock)),
+            ]
+        )
+
+    def test_normalize_empty_stream(self):
+        values = [[], "", None]
+        for value in values:
+            with self.subTest(value=value):
+                self.assertEqual(
+                    self.simple_block.normalize(value),
+                    blocks.StreamValue(self.simple_block, []),
+                )
+
+    def test_normalize_base_case(self):
+        """
+        Test normalize when trivially recursive, or already a StreamValue
+        """
+        value = [("number", 1), ("text", "ichiban")]
+        stream_value = blocks.StreamValue(self.simple_block, value)
+        self.assertEqual(stream_value, self.simple_block.normalize(value))
+        self.assertEqual(stream_value, self.simple_block.normalize(stream_value))
+
+    def test_normalize_recursive(self):
+        """
+        A stream block is normalized iff all of its sub-blocks are normalized.
+        """
+        values = (
+            # A smart, "list of tuples" representation
+            [
+                ("struct", {"bool": True}),
+                (
+                    "inner_stream",
+                    [
+                        ("number", 1),
+                        ("text", "one"),
+                        ("inner_list", [0, 1, 1, 2, 3, 5]),
+                    ],
+                ),
+                ("list", [0, 1, 1, 2, 3, 5]),
+            ],
+            # A json-ish representation - the serialized format
+            [
+                {"type": "struct", "value": {"bool": True}},
+                {
+                    "type": "inner_stream",
+                    "value": [
+                        {"type": "number", "value": 1},
+                        {"type": "text", "value": "one"},
+                        {
+                            "type": "inner_list",
+                            "value": [
+                                # Unlike StreamBlock, ListBlock requires that its items
+                                # have IDs, to distinguish the new serialization format
+                                # from the old.
+                                {"type": "item", "value": 0, "id": 1},
+                                {"type": "item", "value": 1, "id": 2},
+                                {"type": "item", "value": 2, "id": 3},
+                            ],
+                        },
+                    ],
+                },
+                {
+                    "type": "list",
+                    "value": [
+                        {"type": "item", "value": 0, "id": 1},
+                        {"type": "item", "value": 1, "id": 2},
+                        {"type": "item", "value": 2, "id": 3},
+                    ],
+                },
+            ],
+        )
+
+        for value in values:
+            with self.subTest(value=value):
+                # Normalize the value.
+                normalized = self.recursive_block.normalize(value)
+                # Then check all of the sub-blocks have been normalized:
+                # the StructBlock child
+                self.assertIsInstance(normalized[0].value, blocks.StructValue)
+                self.assertIsInstance(normalized[0].value["bool"], bool)
+                # the nested StreamBlock child
+                self.assertIsInstance(normalized[1].value, blocks.StreamValue)
+                self.assertIsInstance(normalized[1].value[0].value, int)
+                self.assertIsInstance(normalized[1].value[1].value, str)
+                # the ListBlock child
+                self.assertIsInstance(normalized[2].value[0], int)
+                self.assertIsInstance(normalized[2].value, blocks.list_block.ListValue)
+                # the inner ListBlock nested in the nested streamblock
+                self.assertIsInstance(normalized[1].value[2].value[0], int)
+                self.assertIsInstance(
+                    normalized[1].value[2].value, blocks.list_block.ListValue
+                )
+
+
 class TestStructBlockWithFixtures(TestCase):
     fixtures = ["test.json"]
 
@@ -4742,6 +4997,12 @@ class TestStaticBlock(unittest.TestCase):
         result = block.to_python(None)
         self.assertIsNone(result)
 
+    def test_normalize(self):
+        """
+        StaticBlock.normalize always returns None, as a StaticBlock has no value
+        """
+        self.assertIsNone(blocks.StaticBlock().normalize(11))
+
 
 class TestDateBlock(TestCase):
     def test_adapt(self):

wagtail/tests/test_migrations.py

@@ -16,7 +16,7 @@ class TestForMigrations(TestCase):
         app_labels = {
             app.label
             for app in apps.get_app_configs()
-            if app.name.startswith("wagtail.")
+            if app.name.split(".")[0] == "wagtail"
         }
         for app_label in app_labels:
             apps.get_app_config(app_label.split(".")[-1])

wagtail/tests/test_page_model.py

@@ -68,6 +68,7 @@ from wagtail.test.testapp.models import (
     TaggedPage,
 )
 from wagtail.test.utils import WagtailTestUtils
+from wagtail.url_routing import RouteResult
 
 
 def get_ct(model):
@@ -211,6 +212,50 @@ class TestSiteRouting(TestCase):
         self.unrecognised_port = "8000"
         self.unrecognised_hostname = "unknown.site.com"
 
+    def test_route_for_request_query_count(self):
+        request = get_dummy_request(site=self.events_site)
+        with self.assertNumQueries(2):
+            # expect queries for site & page
+            Page.route_for_request(request, request.path)
+        with self.assertNumQueries(0):
+            # subsequent lookups should be cached on the request
+            Page.route_for_request(request, request.path)
+
+    def test_route_for_request_value(self):
+        request = get_dummy_request(site=self.events_site)
+        self.assertFalse(hasattr(request, "_wagtail_route_for_request"))
+        result = Page.route_for_request(request, request.path)
+        self.assertTrue(isinstance(result, RouteResult))
+        self.assertEqual(
+            (result[0], result[1], result[2]),
+            (self.events_site.root_page.specific, [], {}),
+        )
+        self.assertTrue(hasattr(request, "_wagtail_route_for_request"))
+        self.assertIs(request._wagtail_route_for_request, result)
+
+    def test_route_for_request_cached(self):
+        request = get_dummy_request(site=self.events_site)
+        m = Mock()
+        request._wagtail_route_for_request = m
+        with self.assertNumQueries(0):
+            self.assertEqual(Page.route_for_request(request, request.path), m)
+
+    def test_route_for_request_suppresses_404(self):
+        request = get_dummy_request(path="does-not-exist", site=self.events_site)
+        self.assertIsNone(Page.route_for_request(request, request.path))
+
+    def test_find_for_request(self):
+        request_200 = get_dummy_request(site=self.events_site)
+        self.assertEqual(
+            Page.find_for_request(request_200, request_200.path),
+            self.events_site.root_page.specific,
+        )
+        request_404 = get_dummy_request(path="does-not-exist", site=self.events_site)
+        self.assertEqual(
+            Page.find_for_request(request_404, request_404.path),
+            None,
+        )
+
     def test_valid_headers_route_to_specific_site(self):
         # requests with a known Host: header should be directed to the specific site
         request = get_dummy_request(site=self.events_site)
@@ -502,6 +547,20 @@ class TestRouting(TestCase):
                 christmas_page.get_url(request=request), "/events/christmas/"
             )
 
+    def test_cached_parent_obj_set(self):
+        homepage = Page.objects.get(url_path="/home/")
+        christmas_page = EventPage.objects.get(url_path="/home/events/christmas/")
+
+        request = get_dummy_request(path="/events/christmas/")
+        (found_page, args, kwargs) = homepage.route(request, ["events", "christmas"])
+        self.assertEqual(found_page, christmas_page)
+
+        # parent cache should be set
+        events_page = Page.objects.get(url_path="/home/events/").specific
+        with self.assertNumQueries(0):
+            parent = found_page.get_parent(update=False)
+            self.assertEqual(parent, events_page)
+
 
 @override_settings(
     ROOT_URLCONF="wagtail.test.urls_multilang",
@@ -3917,3 +3976,21 @@ class TestPageCacheKey(TestCase):
         self.page.slug = "something-else"
         self.page.save()
         self.assertNotEqual(self.page.cache_key, original_cache_key)
+
+
+class TestPageCachedParentObjExists(TestCase):
+    fixtures = ["test.json"]
+
+    def test_cached_parent_obj_exists(self):
+        # https://github.com/wagtail/wagtail/pull/11737
+
+        # Test if _cached_parent_obj is set after using page.get_parent()
+        # This is treebeard specific, we don't know if their API will change.
+        homepage = Page.objects.get(url_path="/home/")
+        homepage._cached_parent_obj = "_cached_parent_obj_exists"
+        parent = homepage.get_parent(update=False)
+        self.assertEqual(
+            parent,
+            "_cached_parent_obj_exists",
+            "Page.get_parent() (treebeard) no longer uses _cached_parent_obj to cache the parent object",
+        )

wagtail/tests/test_page_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 wagtail.models import Page, PageViewRestriction
 from wagtail.test.utils import WagtailTestUtils
@@ -79,6 +79,23 @@ class TestPagePrivacy(WagtailTestUtils, TestCase):
             )
             self.assertRedirects(response, "/")
 
+    @override_settings(
+        WAGTAIL_PASSWORD_REQUIRED_TEMPLATE="tests/custom_page_password_required.html"
+    )
+    def test_anonymous_user_must_authenticate_with_custom_password_required_template(
+        self
+    ):
+        response = self.client.get("/secret-plans/")
+
+        self.assertNotEqual(
+            "wagtailcore/password_required.html",
+            response.templates[0].name,
+        )
+        self.assertEqual(
+            "tests/custom_page_password_required.html",
+            response.templates[0].name,
+        )
+
     def test_view_restrictions_apply_to_subpages(self):
         underpants_page = Page.objects.get(
             url_path="/home/secret-plans/steal-underpants/"

wagtail/tests/test_rich_text.py

@@ -5,7 +5,7 @@ from django.test import TestCase, override_settings
 from django.utils import translation
 
 from wagtail.fields import RichTextField
-from wagtail.models import Locale, Page
+from wagtail.models import Locale, Page, Site
 from wagtail.rich_text import RichText, RichTextMaxLengthValidator, expand_db_html
 from wagtail.rich_text.feature_registry import FeatureRegistry
 from wagtail.rich_text.pages import PageLinkHandler
@@ -82,16 +82,34 @@ class TestExtractAttrs(TestCase):
 
 
 class TestExpandDbHtml(TestCase):
-    def test_expand_db_html_with_linktype(self):
-        html = '<a id="1" linktype="document">foo</a>'
-        result = expand_db_html(html)
-        self.assertEqual(result, "<a>foo</a>")
+    fixtures = ["test.json"]
 
     def test_expand_db_html_no_linktype(self):
         html = '<a id="1">foo</a>'
         result = expand_db_html(html)
         self.assertEqual(result, '<a id="1">foo</a>')
 
+    def test_invalid_linktype_set_to_empty_link(self):
+        html = '<a id="1" linktype="invalid">foo</a>'
+        result = expand_db_html(html)
+        self.assertEqual(result, "<a>foo</a>")
+
+    def test_valid_linktype_and_reference(self):
+        html = '<a id="1" linktype="document">foo</a>'
+        result = expand_db_html(html)
+        self.assertEqual(result, '<a href="/documents/1/test.pdf">foo</a>')
+
+    def test_valid_linktype_invalid_reference_set_to_empty_link(self):
+        html = '<a id="9999" linktype="document">foo</a>'
+        result = expand_db_html(html)
+        self.assertEqual(result, "<a>foo</a>")
+
+    def test_no_embedtype_remove_tag(self):
+        self.assertEqual(expand_db_html('<embed id="1" />'), "")
+
+    def test_invalid_embedtype_remove_tag(self):
+        self.assertEqual(expand_db_html('<embed id="1" embedtype="invalid" />'), "")
+
     @patch("wagtail.embeds.embeds.get_embed")
     def test_expand_db_html_with_embed(self, get_embed):
         from wagtail.embeds.models import Embed
@@ -101,6 +119,78 @@ class TestExpandDbHtml(TestCase):
         result = expand_db_html(html)
         self.assertIn("test html", result)
 
+    # Override CACHES so we don't generate any cache-related SQL queries
+    # for page site root paths (tests use DatabaseCache otherwise).
+    @override_settings(
+        CACHES={
+            "default": {
+                "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+            },
+        }
+    )
+    def test_expand_db_html_database_queries_pages(self):
+        Site.clear_site_root_paths_cache()
+
+        with self.assertNumQueries(5):
+            expand_db_html(
+                """
+This rich text has 8 page links, and this test verifies that the code uses the
+minimal number of database queries (5) to expand them.
+
+All of these pages should be retrieved with 4 queries, one to do the base
+Page table lookup and then 1 each for the EventIndex, EventPage, and
+SimplePage tables.
+
+<a linktype="page" id="3">This links to an EventIndex page.</a>
+<a linktype="page" id="4">This links to an EventPage page.</a>
+<a linktype="page" id="5">This links to an EventPage page.</a>
+<a linktype="page" id="6">This links to an EventPage page.</a>
+<a linktype="page" id="9">This links to an EventPage page.</a>
+<a linktype="page" id="12">This links to an EventPage page.</a>
+<a linktype="page" id="7">This links to a SimplePage page.</a>
+<a linktype="page" id="11">This links to a SimplePage page.</a>
+
+Finally there's one additional query needed to do the Site root paths lookup.
+        """
+            )
+
+    def test_expand_db_html_database_queries_documents(self):
+        with self.assertNumQueries(1):
+            expand_db_html(
+                html="""
+This rich text has 2 document links, and this test verifies that the code uses
+the minimal number of database queries (1) to expand them.
+
+Both of these documents should be retrieved with 1 query:
+
+<a linktype="document" id="1">This links to a document.</a>
+<a linktype="document" id="2">This links to another document.</a>
+"""
+            )
+
+    # Disable rendition cache that might be populated by other tests.
+    @override_settings(
+        CACHES={
+            "renditions": {
+                "BACKEND": "django.core.cache.backends.dummy.DummyCache",
+            },
+        }
+    )
+    def test_expand_db_html_database_queries_images(self):
+        with self.assertNumQueries(3):
+            expand_db_html(
+                """
+This rich text has 2 image links, and this test verifies that the code uses the
+minimal number of database queries (3) to expand them.
+
+Both of these images should be retrieved with 3 queries, one to fetch the
+image objects in bulk and then one per image to fetch their renditions:
+
+This is an image: <embed embedtype="image" id="1" format="left" />
+This is another image: <embed embedtype="image" id="2" format="left" />
+        """
+            )
+
 
 class TestRichTextValue(TestCase):
     fixtures = ["test.json"]

wagtail/tests/test_streamfield.py

@@ -16,6 +16,7 @@ from wagtail.models import Page
 from wagtail.rich_text import RichText
 from wagtail.signal_handlers import disable_reference_index_auto_update
 from wagtail.test.testapp.models import (
+    ComplexDefaultStreamPage,
     JSONBlockCountsStreamModel,
     JSONMinMaxCountStreamModel,
     JSONStreamModel,
@@ -236,6 +237,48 @@ class TestStreamValueAccess(TestCase):
         self.assertEqual(fetched_body[1].block_type, "text")
         self.assertEqual(fetched_body[1].value, "bar")
 
+    def test_complex_assignment(self):
+        page = StreamPage(title="Test page", body=[])
+        page.body = [
+            ("rich_text", "<h2>hello world</h2>"),
+            (
+                "books",
+                [
+                    ("title", "Great Expectations"),
+                    ("author", "Charles Dickens"),
+                ],
+            ),
+        ]
+        self.assertEqual(page.body[0].block_type, "rich_text")
+        self.assertIsInstance(page.body[0].value, RichText)
+        self.assertEqual(page.body[0].value.source, "<h2>hello world</h2>")
+        self.assertEqual(page.body[1].block_type, "books")
+        self.assertIsInstance(page.body[1].value, StreamValue)
+        self.assertEqual(len(page.body[1].value), 2)
+        self.assertEqual(page.body[1].value[0].block_type, "title")
+        self.assertEqual(page.body[1].value[0].value, "Great Expectations")
+        self.assertEqual(page.body[1].value[1].block_type, "author")
+        self.assertEqual(page.body[1].value[1].value, "Charles Dickens")
+
+
+class TestComplexDefault(TestCase):
+    def setUp(self):
+        self.page = ComplexDefaultStreamPage(title="Test page")
+
+    def test_default_value(self):
+        self.assertEqual(self.page.body[0].block_type, "rich_text")
+        self.assertIsInstance(self.page.body[0].value, RichText)
+        self.assertEqual(
+            self.page.body[0].value.source, "<p>My <i>lovely</i> books</p>"
+        )
+        self.assertEqual(self.page.body[1].block_type, "books")
+        self.assertIsInstance(self.page.body[1].value, StreamValue)
+        self.assertEqual(len(self.page.body[1].value), 2)
+        self.assertEqual(self.page.body[1].value[0].block_type, "title")
+        self.assertEqual(self.page.body[1].value[0].value, "The Great Gatsby")
+        self.assertEqual(self.page.body[1].value[1].block_type, "author")
+        self.assertEqual(self.page.body[1].value[1].value, "F. Scott Fitzgerald")
+
 
 class TestStreamFieldRenderingBase(TestCase):
     model = JSONStreamModel

wagtail/tests/test_utils.py

@@ -178,14 +178,14 @@ class TestInvokeViaAttributeShortcut(SimpleTestCase):
             pickled = pickle.dumps(self.test_object, -1)
         except Exception as e:  # noqa: BLE001
             raise AssertionError(
-                "An error occured when attempting to pickle %r: %s"
+                "An error occurred when attempting to pickle %r: %s"
                 % (self.test_object, e)
             )
         try:
             self.test_object = pickle.loads(pickled)
         except Exception as e:  # noqa: BLE001
             raise AssertionError(
-                "An error occured when attempting to unpickle %r: %s"
+                "An error occurred when attempting to unpickle %r: %s"
                 % (self.test_object, e)
             )
 
@@ -479,6 +479,12 @@ class TestGetDummyRequest(TestCase):
         request = get_dummy_request(site=site)
         self.assertEqual(request.get_host(), "other.example.com:8888")
 
+    def test_server_name_for_wildcard_allowed_hosts(self):
+        # Django's test runner adds "testserver" at the end of ALLOWED_HOSTS.
+        with self.settings(ALLOWED_HOSTS=["*", "testserver"]):
+            request = get_dummy_request()
+            self.assertEqual(request.get_host(), "example.com")
+
 
 class TestDeepUpdate(TestCase):
     def test_deep_update(self):