wagtail 6.3.2__py3-none-any.whl → 6.4rc1__py3-none-any.whl

wagtail/tests/test_management_commands.py

@@ -5,6 +5,7 @@ from unittest import mock
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import Group
 from django.core import management
+from django.core.cache import cache
 from django.db import models
 from django.test import TestCase, override_settings
 from django.utils import timezone
@@ -177,10 +178,19 @@ class TestSetUrlPathsCommand(TestCase):
         self.run_command()
 
 
+@override_settings(
+    CACHES={
+        "default": {
+            "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+        },
+    }
+)
 class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
     fixtures = ["test.json"]
 
     def setUp(self):
+        cache.clear()
+
         # Find root page
         self.root_page = Page.objects.get(id=2)
 
@@ -215,8 +225,9 @@ class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
                 .exclude(approved_go_live_at__isnull=True)
                 .exists()
             )
-
-            management.call_command("publish_scheduled_pages")
+            with self.assertNumQueries(49):
+                with self.captureOnCommitCallbacks(execute=True):
+                    management.call_command("publish_scheduled_pages")
 
             p = Page.objects.get(slug="hello-world")
             self.assertTrue(p.live)
@@ -272,7 +283,9 @@ class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
                 .exists()
             )
 
-            management.call_command("publish_scheduled_pages")
+            with self.assertNumQueries(49):
+                with self.captureOnCommitCallbacks(execute=True):
+                    management.call_command("publish_scheduled_pages")
 
             p = Page.objects.get(slug="hello-world")
             self.assertTrue(p.live)
@@ -307,7 +320,9 @@ class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
         page.title = "Goodbye world!"
         page.save_revision()
 
-        management.call_command("publish_scheduled_pages")
+        with self.assertNumQueries(49):
+            with self.captureOnCommitCallbacks(execute=True):
+                management.call_command("publish_scheduled_pages")
 
         p = Page.objects.get(slug="hello-world")
         self.assertTrue(p.live)
@@ -334,7 +349,9 @@ class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
             .exists()
         )
 
-        management.call_command("publish_scheduled_pages")
+        with self.assertNumQueries(47):
+            with self.captureOnCommitCallbacks(execute=True):
+                management.call_command("publish_scheduled_pages")
 
         p = Page.objects.get(slug="hello-world")
         self.assertFalse(p.live)
@@ -369,7 +386,9 @@ class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
             p = Page.objects.get(slug="hello-world")
             self.assertTrue(p.live)
 
-            management.call_command("publish_scheduled_pages")
+            with self.assertNumQueries(29):
+                with self.captureOnCommitCallbacks(execute=True):
+                    management.call_command("publish_scheduled_pages")
 
             p = Page.objects.get(slug="hello-world")
             self.assertFalse(p.live)
@@ -396,17 +415,27 @@ class TestPublishScheduledPagesCommand(WagtailTestUtils, TestCase):
         p = Page.objects.get(slug="hello-world")
         self.assertTrue(p.live)
 
-        management.call_command("publish_scheduled_pages")
+        with self.assertNumQueries(6):
+            with self.captureOnCommitCallbacks(execute=True):
+                management.call_command("publish_scheduled_pages")
 
         p = Page.objects.get(slug="hello-world")
         self.assertTrue(p.live)
         self.assertFalse(p.expired)
 
 
+@override_settings(
+    CACHES={
+        "default": {
+            "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+        },
+    }
+)
 class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
     fixtures = ["test.json"]
 
     def setUp(self):
+        cache.clear()
         self.snippet = DraftStateModel.objects.create(text="Hello world!", live=False)
 
     def test_go_live_will_be_published(self):
@@ -435,7 +464,9 @@ class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
                 .exists()
             )
 
-            management.call_command("publish_scheduled")
+            with self.assertNumQueries(15):
+                with self.captureOnCommitCallbacks(execute=True):
+                    management.call_command("publish_scheduled")
 
             self.snippet.refresh_from_db()
             self.assertTrue(self.snippet.live)
@@ -482,7 +513,9 @@ class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
                 .exists()
             )
 
-            management.call_command("publish_scheduled")
+            with self.assertNumQueries(15):
+                with self.captureOnCommitCallbacks(execute=True):
+                    management.call_command("publish_scheduled")
 
             self.snippet.refresh_from_db()
             self.assertTrue(self.snippet.live)
@@ -510,7 +543,9 @@ class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
         self.snippet.text = "Goodbye world!"
         self.snippet.save_revision()
 
-        management.call_command("publish_scheduled")
+        with self.assertNumQueries(15):
+            with self.captureOnCommitCallbacks(execute=True):
+                management.call_command("publish_scheduled")
 
         self.snippet.refresh_from_db()
         self.assertTrue(self.snippet.live)
@@ -533,7 +568,9 @@ class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
             .exists()
         )
 
-        management.call_command("publish_scheduled")
+        with self.assertNumQueries(14):
+            with self.captureOnCommitCallbacks(execute=True):
+                management.call_command("publish_scheduled")
 
         self.assertFalse(self.snippet.live)
         self.assertTrue(
@@ -560,7 +597,9 @@ class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
             self.snippet.refresh_from_db()
             self.assertTrue(self.snippet.live)
 
-            management.call_command("publish_scheduled")
+            with self.assertNumQueries(10):
+                with self.captureOnCommitCallbacks(execute=True):
+                    management.call_command("publish_scheduled")
 
             self.snippet.refresh_from_db()
             self.assertFalse(self.snippet.live)
@@ -580,7 +619,9 @@ class TestPublishScheduledCommand(WagtailTestUtils, TestCase):
         self.snippet.refresh_from_db()
         self.assertTrue(self.snippet.live)
 
-        management.call_command("publish_scheduled")
+        with self.assertNumQueries(6):
+            with self.captureOnCommitCallbacks(execute=True):
+                management.call_command("publish_scheduled")
 
         self.snippet.refresh_from_db()
         self.assertTrue(self.snippet.live)

wagtail/tests/test_page_allowed_http_methods.py

@@ -0,0 +1,32 @@
+from django.test import TestCase
+
+from wagtail.models import Page, Site
+from wagtail.test.testapp.models import EventIndex
+
+
+class AllowedHttpMethodsTestCase(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        super().setUpTestData()
+        site = Site.objects.select_related("root_page").get(is_default_site=True)
+        cls.page = Page(title="Page", slug="page")
+        site.root_page.add_child(instance=cls.page)
+        cls.event_index_page = EventIndex(title="Event index", slug="event-index")
+        site.root_page.add_child(instance=cls.event_index_page)
+
+    def test_options_request_for_default_page(self):
+        response = self.client.options(self.page.url)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            response["Allow"], "DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT"
+        )
+
+    def test_options_request_for_restricted_page(self):
+        response = self.client.options(self.event_index_page.url)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response["Allow"], "GET, OPTIONS")
+
+    def test_invalid_request_method_for_restricted_page(self):
+        response = self.client.post(self.event_index_page.url)
+        self.assertEqual(response.status_code, 405)
+        self.assertEqual(response["Allow"], "GET, OPTIONS")

wagtail/tests/test_page_model.py

@@ -10,6 +10,7 @@ from django.core.exceptions import ValidationError
 from django.http import Http404
 from django.test import Client, TestCase, override_settings
 from django.test.client import RequestFactory
+from django.urls import reverse
 from django.utils import timezone, translation
 from freezegun import freeze_time
 
@@ -326,6 +327,12 @@ class TestSiteRouting(TestCase):
                 Site.find_for_request(request), self.alternate_port_events_site
             )
 
+    def test_site_with_disallowed_host(self):
+        request = get_dummy_request()
+        request.META["HTTP_HOST"] = "disallowed:80"
+        with self.assertNumQueries(1):
+            self.assertEqual(Site.find_for_request(request), self.default_site)
+
 
 class TestRouting(TestCase):
     fixtures = ["test.json"]
@@ -3994,3 +4001,64 @@ class TestPageCachedParentObjExists(TestCase):
             "_cached_parent_obj_exists",
             "Page.get_parent() (treebeard) no longer uses _cached_parent_obj to cache the parent object",
         )
+
+
+class TestPageServeWithPasswordRestriction(TestCase, WagtailTestUtils):
+    def setUp(self):
+        self.root_page = Page.objects.get(id=2)
+        self.test_page = Page(
+            title="Test Page",
+            slug="test",
+        )
+        self.root_page.add_child(instance=self.test_page)
+
+        self.password_restriction = PageViewRestriction.objects.create(
+            page=self.test_page,
+            restriction_type=PageViewRestriction.PASSWORD,
+            password="password123",
+        )
+
+    def test_page_with_password_restriction_authenticated_has_cache_headers(self):
+        auth_url = reverse(
+            "wagtailcore_authenticate_with_password",
+            args=[self.password_restriction.id, self.test_page.id],
+        )
+
+        post_response = self.client.post(
+            auth_url,
+            {
+                "password": "password123",
+                "return_url": "/test/",
+            },
+        )
+
+        self.assertRedirects(post_response, "/test/")
+
+        response = self.client.get("/test/")
+
+        self.assertTrue("Cache-Control" in response)
+        self.assertIn("max-age=0", response["Cache-Control"])
+        self.assertIn("no-cache", response["Cache-Control"])
+        self.assertIn("no-store", response["Cache-Control"])
+        self.assertIn("must-revalidate", response["Cache-Control"])
+        self.assertIn("private", response["Cache-Control"])
+        self.assertTrue("Expires" in response)
+
+    def test_page_with_password_restriction_has_cache_headers(self):
+        response = self.client.get("/test/")
+
+        self.assertTrue("Cache-Control" in response)
+        self.assertIn("max-age=0", response["Cache-Control"])
+        self.assertIn("no-cache", response["Cache-Control"])
+        self.assertIn("no-store", response["Cache-Control"])
+        self.assertIn("must-revalidate", response["Cache-Control"])
+        self.assertIn("private", response["Cache-Control"])
+        self.assertTrue("Expires" in response)
+
+    def test_page_without_password_restriction_has_no_cache_headers(self):
+        self.password_restriction.delete()
+
+        response = self.client.get("/test/")
+
+        self.assertFalse("Cache-Control" in response)
+        self.assertFalse("Expires" in response)

wagtail/tests/test_page_privacy.py

@@ -231,3 +231,13 @@ class TestPagePrivacy(WagtailTestUtils, TestCase):
         response = self.client.get("/secret-login-plans/")
         self.assertEqual(response.status_code, 200)
         self.assertContains(response, "<title>Secret login plans</title>")
+
+    def test_password_protected_page_headers(self):
+        response = self.client.get("/secret-plans/")
+        self.assertEqual(
+            response.templates[0].name, "wagtailcore/password_required.html"
+        )
+        self.assertIn("no-cache", response["Cache-Control"])
+        self.assertIn("no-store", response["Cache-Control"])
+        self.assertIn("must-revalidate", response["Cache-Control"])
+        self.assertIn("max-age=0", response["Cache-Control"])

wagtail/tests/test_page_queryset.py

@@ -919,6 +919,85 @@ class TestSpecificQuery(WagtailTestUtils, TestCase):
         self.assertEqual(results.first().subscribers_count, 1)
         self.assertEqual(results.last().subscribers_count, 1)
 
+    def test_specific_subquery_select_related(self):
+        with self.assertNumQueries(2):
+            pages = list(
+                Page.objects.type(EventPage)
+                .specific()
+                .select_related("feed_image", for_specific_subqueries=True)
+            )
+        self.assertEqual(len(pages), 4)
+        with self.assertNumQueries(0):
+            for page in pages:
+                self.assertTrue(page.feed_image)
+
+    def test_specific_subquery_select_related_without_fields(
+        self,
+    ):
+        with self.assertRaises(ValueError):
+            Page.objects.all().select_related(for_specific_subqueries=True)
+
+    def test_specific_subquery_select_related_negation(self):
+        with self.assertNumQueries(2):
+            pages = list(
+                Page.objects.type(EventPage)
+                .specific()
+                .select_related("feed_image", for_specific_subqueries=True)
+                .select_related(
+                    None, for_specific_subqueries=True
+                )  # This should negate the above line
+            )
+        with self.assertNumQueries(4):
+            for page in pages:
+                self.assertTrue(page.feed_image)
+
+    def test_specific_subquery_prefetch_related(self):
+        with self.assertNumQueries(3):
+            pages = list(
+                Page.objects.type(EventPage)
+                .specific()
+                .prefetch_related("categories", for_specific_subqueries=True)
+            )
+        self.assertEqual(len(pages), 4)
+        with self.assertNumQueries(0):
+            for page in pages:
+                self.assertFalse(page.categories.all())
+
+    def test_specific_subquery_prefetch_related_without_lookups(self):
+        with self.assertRaises(ValueError):
+            Page.objects.all().prefetch_related(for_specific_subqueries=True)
+
+    def test_specific_subquery_prefetch_related_negation(self):
+        with self.assertNumQueries(2):
+            pages = list(
+                Page.objects.type(EventPage)
+                .specific()
+                .prefetch_related("categories", for_specific_subqueries=True)
+                .prefetch_related(
+                    None, for_specific_subqueries=True
+                )  # This should negate the above line
+            )
+        self.assertEqual(len(pages), 4)
+        with self.assertNumQueries(4):
+            for page in pages:
+                self.assertFalse(page.categories.all())
+
+    def test_specific_subquery_select_related_and_prefetch_related(self):
+        with self.assertNumQueries(3):
+            pages = list(
+                Page.objects.type(EventPage)
+                .specific()
+                .select_related("feed_image", for_specific_subqueries=True)
+                .prefetch_related(
+                    "feed_image__renditions", for_specific_subqueries=True
+                )
+            )
+        self.assertEqual(len(pages), 4)
+        with self.assertNumQueries(0):
+            for page in pages:
+                self.assertTrue(page.feed_image)
+                self.assertFalse(page.feed_image.renditions.all())
+
     def test_specific_query_with_alias(self):
         """
         Ensure alias() works with specific() queries.

wagtail/tests/test_reference_index.py

@@ -28,45 +28,46 @@ from wagtail.test.testapp.models import (
 
 class TestCreateOrUpdateForObject(TestCase):
     def setUp(self):
-        image_model = get_image_model()
-        self.image_content_type = ContentType.objects.get_for_model(image_model)
+        with self.captureOnCommitCallbacks(execute=True):
+            image_model = get_image_model()
+            self.image_content_type = ContentType.objects.get_for_model(image_model)
 
-        self.test_feed_image = image_model.objects.create(
-            title="Test feed image",
-            file=get_test_image_file(),
-        )
-        self.test_image_1 = image_model.objects.create(
-            title="Test image 1",
-            file=get_test_image_file(),
-        )
-        self.test_image_2 = image_model.objects.create(
-            title="Test image 2",
-            file=get_test_image_file(),
-        )
+            self.test_feed_image = image_model.objects.create(
+                title="Test feed image",
+                file=get_test_image_file(),
+            )
+            self.test_image_1 = image_model.objects.create(
+                title="Test image 1",
+                file=get_test_image_file(),
+            )
+            self.test_image_2 = image_model.objects.create(
+                title="Test image 2",
+                file=get_test_image_file(),
+            )
 
-        # Add event page
-        self.event_page = EventPage(
-            title="Event page",
-            slug="event-page",
-            location="the moon",
-            audience="public",
-            cost="free",
-            date_from="2001-01-01",
-            feed_image=self.test_feed_image,
-        )
-        self.event_page.carousel_items = [
-            EventPageCarouselItem(
-                caption="1234567", image=self.test_image_1, sort_order=1
-            ),
-            EventPageCarouselItem(
-                caption="7654321", image=self.test_image_2, sort_order=2
-            ),
-            EventPageCarouselItem(
-                caption="abcdefg", image=self.test_image_1, sort_order=3
-            ),
-        ]
-        self.root_page = Page.objects.get(id=2)
-        self.root_page.add_child(instance=self.event_page)
+            # Add event page
+            self.event_page = EventPage(
+                title="Event page",
+                slug="event-page",
+                location="the moon",
+                audience="public",
+                cost="free",
+                date_from="2001-01-01",
+                feed_image=self.test_feed_image,
+            )
+            self.event_page.carousel_items = [
+                EventPageCarouselItem(
+                    caption="1234567", image=self.test_image_1, sort_order=1
+                ),
+                EventPageCarouselItem(
+                    caption="7654321", image=self.test_image_2, sort_order=2
+                ),
+                EventPageCarouselItem(
+                    caption="abcdefg", image=self.test_image_1, sort_order=3
+                ),
+            ]
+            self.root_page = Page.objects.get(id=2)
+            self.root_page.add_child(instance=self.event_page)
 
         self.expected_references = {
             (
@@ -168,8 +169,9 @@ class TestCreateOrUpdateForObject(TestCase):
         )
 
     def test_saving_base_model_does_not_remove_references(self):
-        page = Page.objects.get(pk=self.event_page.pk)
-        page.save()
+        with self.captureOnCommitCallbacks(execute=True):
+            page = Page.objects.get(pk=self.event_page.pk)
+            page.save()
         self.assertSetEqual(
             set(
                 ReferenceIndex.get_references_for_object(self.event_page).values_list(
@@ -180,11 +182,12 @@ class TestCreateOrUpdateForObject(TestCase):
         )
 
     def test_null_parental_key(self):
-        obj = ModelWithNullableParentalKey(
-            content="""<p><a linktype="page" id="%d">event page</a></p>"""
-            % self.event_page.id
-        )
-        obj.save()
+        with self.captureOnCommitCallbacks(execute=True):
+            obj = ModelWithNullableParentalKey(
+                content="""<p><a linktype="page" id="%d">event page</a></p>"""
+                % self.event_page.id
+            )
+            obj.save()
 
         # Models with a ParentalKey are not considered indexable - references are recorded against the parent model
         # instead. Since the ParentalKey is null here, no reference will be recorded.
@@ -192,51 +195,56 @@ class TestCreateOrUpdateForObject(TestCase):
         self.assertEqual(refs.count(), 0)
 
     def test_lazy_parental_key(self):
-        event_page_related_link = EventPageRelatedLink()
-        # The parent model is a lazy object
-        event_page_related_link.page = SimpleLazyObject(lambda: self.event_page)
-        event_page_related_link.link_page = self.root_page
-        event_page_related_link.save()
+        with self.captureOnCommitCallbacks(execute=True):
+            event_page_related_link = EventPageRelatedLink()
+            # The parent model is a lazy object
+            event_page_related_link.page = SimpleLazyObject(lambda: self.event_page)
+            event_page_related_link.link_page = self.root_page
+            event_page_related_link.save()
         refs = ReferenceIndex.get_references_to(self.root_page)
         self.assertEqual(refs.count(), 1)
 
     def test_generic_foreign_key(self):
-        page1 = GenericSnippetPage(
-            title="generic snippet page", snippet_content_object=self.event_page
-        )
-        self.root_page.add_child(instance=page1)
-        page2 = GenericSnippetPage(
-            title="generic snippet page", snippet_content_object=None
-        )
-        self.root_page.add_child(instance=page2)
+        with self.captureOnCommitCallbacks(execute=True):
+            page1 = GenericSnippetPage(
+                title="generic snippet page", snippet_content_object=self.event_page
+            )
+            self.root_page.add_child(instance=page1)
+            page2 = GenericSnippetPage(
+                title="generic snippet page", snippet_content_object=None
+            )
+            self.root_page.add_child(instance=page2)
 
         refs = ReferenceIndex.get_references_to(self.event_page)
         self.assertEqual(refs.count(), 1)
 
     def test_model_index_ignore_generic_foreign_key(self):
-        page1 = GenericSnippetNoIndexPage(
-            title="generic snippet page", snippet_content_object=self.event_page
-        )
-        self.root_page.add_child(instance=page1)
-        page2 = GenericSnippetNoIndexPage(
-            title="generic snippet page", snippet_content_object=None
-        )
-        self.root_page.add_child(instance=page2)
+        with self.captureOnCommitCallbacks(execute=True):
+            page1 = GenericSnippetNoIndexPage(
+                title="generic snippet page", snippet_content_object=self.event_page
+            )
+            self.root_page.add_child(instance=page1)
+            page2 = GenericSnippetNoIndexPage(
+                title="generic snippet page", snippet_content_object=None
+            )
+            self.root_page.add_child(instance=page2)
 
         # There should be no references
         refs = ReferenceIndex.get_references_to(self.event_page)
         self.assertEqual(refs.count(), 0)
 
     def test_model_field_index_ignore_generic_foreign_key(self):
-        content_type = ContentType.objects.get_for_model(self.event_page)
-        page1 = GenericSnippetNoFieldIndexPage(
-            title="generic snippet page", snippet_content_type_nonindexed=content_type
-        )
-        self.root_page.add_child(instance=page1)
-        page2 = GenericSnippetNoFieldIndexPage(
-            title="generic snippet page", snippet_content_type_nonindexed=None
-        )
-        self.root_page.add_child(instance=page2)
+        with self.captureOnCommitCallbacks(execute=True):
+            content_type = ContentType.objects.get_for_model(self.event_page)
+            page1 = GenericSnippetNoFieldIndexPage(
+                title="generic snippet page",
+                snippet_content_type_nonindexed=content_type,
+            )
+            self.root_page.add_child(instance=page1)
+            page2 = GenericSnippetNoFieldIndexPage(
+                title="generic snippet page", snippet_content_type_nonindexed=None
+            )
+            self.root_page.add_child(instance=page2)
 
         # There should be no references
         refs = ReferenceIndex.get_references_to(content_type)
@@ -449,7 +457,8 @@ class TestDescribeOnDelete(TestCase):
                 if "on_delete_set_default" not in init_kwargs:
                     init_kwargs["on_delete_set_default"] = None
 
-                obj = VariousOnDeleteModel.objects.create(**init_kwargs)
+                with self.captureOnCommitCallbacks(execute=True):
+                    obj = VariousOnDeleteModel.objects.create(**init_kwargs)
                 usage = ReferenceIndex.get_references_to(
                     referred_object
                 ).group_by_source_object()

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")
+
     def test_complex_assignment(self):
         page = StreamPage(title="Test page", body=[])
         page.body = [
@@ -279,6 +297,18 @@ class TestComplexDefault(TestCase):
         self.assertEqual(self.page.body[1].value[1].block_type, "author")
         self.assertEqual(self.page.body[1].value[1].value, "F. Scott Fitzgerald")
 
+    def test_creation_form_with_initial_instance(self):
+        form_class = ComplexDefaultStreamPage.get_edit_handler().get_form_class()
+        form = form_class(instance=self.page)
+        form_html = form.as_p()
+        self.assertIn("The Great Gatsby", form_html)
+
+    def test_creation_form_without_initial_instance(self):
+        form_class = ComplexDefaultStreamPage.get_edit_handler().get_form_class()
+        form = form_class()
+        form_html = form.as_p()
+        self.assertIn("The Great Gatsby", form_html)
+
 
 class TestStreamFieldRenderingBase(TestCase):
     model = JSONStreamModel