wagtail 7.0.2__py3-none-any.whl → 7.1rc1__py3-none-any.whl

wagtail/tests/test_page_model.py

@@ -1,4 +1,5 @@
 import datetime
+import json
 import unittest
 from unittest.mock import Mock
 
@@ -49,6 +50,7 @@ from wagtail.test.testapp.models import (
     EventIndex,
     EventPage,
     EventPageSpeaker,
+    ExcludedCopyPageNote,
     GenericSnippetPage,
     ManyToManyBlogPage,
     MTIBasePage,
@@ -1994,24 +1996,34 @@ class TestCopyPage(TestCase):
 
     def test_copy_page_with_additional_excluded_fields(self):
         homepage = Page.objects.get(url_path="/home/")
-        page = homepage.add_child(
-            instance=PageWithExcludedCopyField(
-                title="Discovery",
-                slug="disco",
-                content="NCC-1031",
-                special_field="Context is for Kings",
-            )
-        )
+        page = PageWithExcludedCopyField(
+            title="Discovery",
+            slug="disco",
+            content="NCC-1031",
+            special_field="Context is for Kings",
+            special_stream=[("item", "non-default item")],
+        )
+        page.special_notes = [ExcludedCopyPageNote(note="Some note")]
+        homepage.add_child(instance=page)
         page.save_revision()
         new_page = page.copy(to=homepage, update_attrs={"slug": "disco-2"})
-        exclude_field = new_page.latest_revision.content["special_field"]
+        revision_content = new_page.latest_revision.content
 
         self.assertEqual(page.title, new_page.title)
         self.assertNotEqual(page.id, new_page.id)
         self.assertNotEqual(page.path, new_page.path)
-        # special_field is in the list to be excluded
-        self.assertNotEqual(page.special_field, new_page.special_field)
-        self.assertEqual(new_page.special_field, exclude_field)
+
+        # special_field and special_stream are in the list to be excluded,
+        # and should revert to the default
+        self.assertEqual(new_page.special_field, "Very Special")
+        self.assertEqual(revision_content["special_field"], "Very Special")
+        self.assertEqual(new_page.special_stream[0].value, "default item")
+        stream_data = json.loads(revision_content["special_stream"])
+        self.assertEqual(stream_data[0]["value"], "default item")
+
+        # The special_notes relation should be cleared on the new page
+        self.assertEqual(new_page.special_notes.count(), 0)
+        self.assertEqual(revision_content["special_notes"], [])
 
     def test_page_with_generic_relation(self):
         """Test that a page with a GenericRelation will have that relation ignored when
@@ -3622,16 +3634,47 @@ class TestPageWithContentJSON(TestCase):
             "locked_by",
             "locked_at",
             "latest_revision_created_at",
-            "first_published_at",
         ):
             self.assertEqual(
                 getattr(original_page, attr_name), getattr(updated_page, attr_name)
             )
 
+        # first_published_at has special behavior: it's only preserved if the content doesn't provide a value
+        # Since we provided a value in the content, it should use that value instead of preserving the original
+        self.assertNotEqual(
+            original_page.first_published_at, updated_page.first_published_at
+        )
+
         # The url_path should reflect the new slug value, but the
         # rest of the path should have remained unchanged
         self.assertEqual(updated_page.url_path, "/home/about-them/")
 
+    def test_with_content_json_preserves_first_published_at_when_none(self):
+        original_page = SimplePage.objects.get(url_path="/home/about-us/")
+
+        # When first_published_at is None in content, it should preserve the original value
+        content_with_none = original_page.serializable_data()
+        content_with_none["first_published_at"] = None
+
+        updated_page_none = original_page.with_content_json(content_with_none)
+
+        self.assertEqual(
+            original_page.first_published_at, updated_page_none.first_published_at
+        )
+
+    def test_with_content_json_uses_first_published_at_when_provided(self):
+        original_page = SimplePage.objects.get(url_path="/home/about-us/")
+
+        # When first_published_at has a value in content, it should use that value
+        content_with_value = original_page.serializable_data()
+        content_with_value["first_published_at"] = "2000-01-01T00:00:00Z"
+
+        updated_page_value = original_page.with_content_json(content_with_value)
+
+        self.assertNotEqual(
+            original_page.first_published_at, updated_page_value.first_published_at
+        )
+
 
 class TestUnpublish(TestCase):
     fixtures = ["test.json"]

wagtail/tests/test_reference_index.py

@@ -2,6 +2,8 @@ from io import StringIO
 
 from django.contrib.contenttypes.models import ContentType
 from django.core import management
+from django.core.exceptions import FieldDoesNotExist
+from django.db import models
 from django.test import TestCase
 from django.utils.functional import SimpleLazyObject
 
@@ -18,6 +20,7 @@ from wagtail.test.testapp.models import (
     EventPage,
     EventPageCarouselItem,
     EventPageRelatedLink,
+    EventPageSpeaker,
     GenericSnippetNoFieldIndexPage,
     GenericSnippetNoIndexPage,
     GenericSnippetPage,
@@ -526,3 +529,352 @@ class TestDescribeOnDelete(TestCase):
                 reference.describe_on_delete(),
                 "the advert placement will also be deleted",
             )
+
+    def test_parental_key_with_related_query_name(self):
+        # EventPageSpeaker has a ParentalKey to EventPage with a
+        # related_query_name that is different from the related_name, which
+        # causes a mismatch between the recorded model_path and the way we
+        # introspect the source field.
+        root_page = Page.objects.get(id=2)
+        speaker = EventPageSpeaker(
+            first_name="Willie", last_name="Wagtail", link_page=root_page
+        )
+        event_page = EventPage.objects.first()
+        event_page.speakers.add(speaker)
+        with self.captureOnCommitCallbacks(execute=True):
+            event_page.save()
+        refs = ReferenceIndex.get_references_to(root_page)
+        self.assertEqual(refs.count(), 1)
+        self.assertEqual(refs[0].describe_source_field(), "Link page")
+        self.assertEqual(
+            refs[0].describe_on_delete(),
+            "the event page speaker will also be deleted",
+        )
+
+    def test_nonexistent_field(self):
+        # Simulate a situation where the field does not exist on the model
+        # (e.g. due to a stale reference after the field was removed or renamed)
+        reference = ReferenceIndex.objects.create(
+            base_content_type=ReferenceIndex._get_base_content_type(self.advert),
+            content_type=ContentType.objects.get_for_model(self.advert),
+            object_id=self.advert.pk,
+            to_content_type=ContentType.objects.get_for_model(self.page),
+            to_object_id=self.page.pk,
+            model_path="nonexistent_field",
+            content_path="some_path",
+            content_path_hash=ReferenceIndex._get_content_path_hash("some_path"),
+        )
+        with self.assertRaises(FieldDoesNotExist):
+            reference.describe_source_field()
+
+
+class TestBulkFetch(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.image_model = get_image_model()
+        cls.document_model = get_document_model()
+
+        cls.test_image_1 = cls.image_model.objects.create(
+            title="Test image 1",
+            file=get_test_image_file(),
+        )
+        cls.test_image_2 = cls.image_model.objects.create(
+            title="Test image 2",
+            file=get_test_image_file(),
+        )
+        cls.test_image_3 = cls.image_model.objects.create(
+            title="Test image 3",
+            file=get_test_image_file(),
+        )
+        cls.test_document_1 = cls.document_model.objects.create(
+            title="Test document 1",
+            file=get_test_document_file(),
+        )
+        cls.test_document_2 = cls.document_model.objects.create(
+            title="Test document 2",
+            file=get_test_document_file(),
+        )
+
+        cls.event_page = EventPage(
+            title="Event page",
+            slug="event-page",
+            location="the moon",
+            audience="public",
+            cost="free",
+            date_from="2001-01-01",
+            feed_image=cls.test_image_1,
+        )
+        cls.event_page.carousel_items = [
+            EventPageCarouselItem(
+                caption="hello image 1", image=cls.test_image_1, sort_order=1
+            ),
+            EventPageCarouselItem(
+                caption="hi image 2", image=cls.test_image_2, sort_order=2
+            ),
+            EventPageCarouselItem(
+                caption="it's image 1 again", image=cls.test_image_1, sort_order=3
+            ),
+            EventPageCarouselItem(
+                caption="now a doc", link_document=cls.test_document_2, sort_order=4
+            ),
+        ]
+        cls.root_page = Page.objects.get(id=2)
+
+        with cls.captureOnCommitCallbacks(execute=True):
+            cls.root_page.add_child(instance=cls.event_page)
+            cls.event_page.save()
+
+        cls.carousel_items = list(cls.event_page.carousel_items.order_by("sort_order"))
+
+    def test_get_references_to_in_bulk_with_empty_queryset_or_list(self):
+        with self.assertNumQueries(0):
+            refs = ReferenceIndex.get_references_to_in_bulk(
+                get_image_model().objects.none()
+            )
+            self.assertIsInstance(refs, models.QuerySet)
+            self.assertEqual(len(refs), 0)
+
+        with self.assertNumQueries(0):
+            refs = ReferenceIndex.get_references_to_in_bulk([])
+            self.assertIsInstance(refs, models.QuerySet)
+            self.assertEqual(len(refs), 0)
+
+    def test_get_references_to_in_bulk_with_queryset(self):
+        with self.assertNumQueries(1):
+            refs = ReferenceIndex.get_references_to_in_bulk(
+                get_image_model().objects.filter(
+                    pk__in=[
+                        self.test_image_1.pk,
+                        self.test_image_2.pk,
+                        self.test_image_3.pk,
+                    ]
+                )
+            )
+            self.assertIsInstance(refs, models.QuerySet)
+            self.assertEqual(len(refs), 4)
+
+        simplified_refs = {
+            (
+                ref.to_content_type_id,
+                ref.to_object_id,
+                ref.base_content_type_id,
+                ref.object_id,
+                ref.content_path,
+            )
+            for ref in refs
+        }
+        page_ct = ContentType.objects.get_for_model(Page)
+        image_ct = ContentType.objects.get_for_model(self.image_model)
+        page_id = str(self.event_page.pk)
+        self.assertEqual(
+            simplified_refs,
+            {
+                (
+                    image_ct.pk,
+                    str(self.test_image_1.pk),
+                    page_ct.pk,
+                    page_id,
+                    f"carousel_items.{self.carousel_items[0].pk}.image",
+                ),
+                (
+                    image_ct.pk,
+                    str(self.test_image_1.pk),
+                    page_ct.pk,
+                    page_id,
+                    f"carousel_items.{self.carousel_items[2].pk}.image",
+                ),
+                (
+                    image_ct.pk,
+                    str(self.test_image_1.pk),
+                    page_ct.pk,
+                    page_id,
+                    "feed_image",
+                ),
+                (
+                    image_ct.pk,
+                    str(self.test_image_2.pk),
+                    page_ct.pk,
+                    page_id,
+                    f"carousel_items.{self.carousel_items[1].pk}.image",
+                ),
+            },
+        )
+
+    def test_get_references_to_in_bulk_with_list_of_mixed_instances(self):
+        with self.assertNumQueries(1):
+            refs = ReferenceIndex.get_references_to_in_bulk(
+                [
+                    self.test_image_1,
+                    self.test_image_2,
+                    self.test_document_1,
+                    self.test_document_2,
+                ]
+            )
+            self.assertIsInstance(refs, models.QuerySet)
+            self.assertEqual(len(refs), 5)
+
+        simplified_refs = {
+            (
+                ref.to_content_type_id,
+                ref.to_object_id,
+                ref.base_content_type_id,
+                ref.object_id,
+                ref.content_path,
+            )
+            for ref in refs
+        }
+        page_ct = ContentType.objects.get_for_model(Page)
+        image_ct = ContentType.objects.get_for_model(self.image_model)
+        document_ct = ContentType.objects.get_for_model(self.document_model)
+        page_id = str(self.event_page.pk)
+        self.assertEqual(
+            simplified_refs,
+            {
+                (
+                    image_ct.pk,
+                    str(self.test_image_1.pk),
+                    page_ct.pk,
+                    page_id,
+                    f"carousel_items.{self.carousel_items[0].pk}.image",
+                ),
+                (
+                    image_ct.pk,
+                    str(self.test_image_1.pk),
+                    page_ct.pk,
+                    page_id,
+                    f"carousel_items.{self.carousel_items[2].pk}.image",
+                ),
+                (
+                    image_ct.pk,
+                    str(self.test_image_1.pk),
+                    page_ct.pk,
+                    page_id,
+                    "feed_image",
+                ),
+                (
+                    image_ct.pk,
+                    str(self.test_image_2.pk),
+                    page_ct.pk,
+                    page_id,
+                    f"carousel_items.{self.carousel_items[1].pk}.image",
+                ),
+                (
+                    document_ct.pk,
+                    str(self.test_document_2.pk),
+                    page_ct.pk,
+                    page_id,
+                    f"carousel_items.{self.carousel_items[3].pk}.link_document",
+                ),
+            },
+        )
+
+    def test_get_grouped_references_to_in_bulk_with_empty_queryset_or_list(self):
+        with self.assertNumQueries(0):
+            refs = ReferenceIndex.get_grouped_references_to_in_bulk(
+                get_image_model().objects.none()
+            )
+            self.assertIsInstance(refs, dict)
+            self.assertEqual(len(refs), 0)
+
+        with self.assertNumQueries(0):
+            refs = ReferenceIndex.get_grouped_references_to_in_bulk([])
+            self.assertIsInstance(refs, dict)
+            self.assertEqual(len(refs), 0)
+
+    def test_get_grouped_references_to_in_bulk_with_queryset(self):
+        # Two queries: one to get the references, one to evaluate the images so
+        # that we can map each image to its references
+        with self.assertNumQueries(2):
+            refs = ReferenceIndex.get_grouped_references_to_in_bulk(
+                get_image_model().objects.filter(
+                    pk__in=[
+                        self.test_image_1.pk,
+                        self.test_image_2.pk,
+                        self.test_image_3.pk,
+                    ]
+                )
+            )
+            self.assertIsInstance(refs, dict)
+            self.assertEqual(len(refs), 3)
+
+        expected_refs = {
+            self.test_image_1: [
+                (
+                    self.event_page.page_ptr,
+                    {
+                        f"carousel_items.{self.carousel_items[0].pk}.image",
+                        f"carousel_items.{self.carousel_items[2].pk}.image",
+                        "feed_image",
+                    },
+                )
+            ],
+            self.test_image_2: [
+                (
+                    self.event_page.page_ptr,
+                    {f"carousel_items.{self.carousel_items[1].pk}.image"},
+                )
+            ],
+            self.test_image_3: [],
+        }
+        self.assertEqual(
+            {
+                item: [
+                    (ref_group[0], {ref.content_path for ref in ref_group[1]})
+                    for ref_group in ref_groups
+                ]
+                for item, ref_groups in refs.items()
+            },
+            expected_refs,
+        )
+
+    def test_get_grouped_references_to_in_bulk_with_list_of_mixed_instances(self):
+        # We only need one query to get the references, as the images and
+        # documents are already loaded in memory.
+        with self.assertNumQueries(1):
+            refs = ReferenceIndex.get_grouped_references_to_in_bulk(
+                [
+                    self.test_image_1,
+                    self.test_image_2,
+                    self.test_document_1,
+                    self.test_document_2,
+                ]
+            )
+            self.assertIsInstance(refs, dict)
+            self.assertEqual(len(refs), 4)
+
+        expected_refs = {
+            self.test_image_1: [
+                (
+                    self.event_page.page_ptr,
+                    {
+                        f"carousel_items.{self.carousel_items[0].pk}.image",
+                        f"carousel_items.{self.carousel_items[2].pk}.image",
+                        "feed_image",
+                    },
+                )
+            ],
+            self.test_image_2: [
+                (
+                    self.event_page.page_ptr,
+                    {f"carousel_items.{self.carousel_items[1].pk}.image"},
+                )
+            ],
+            self.test_document_1: [],
+            self.test_document_2: [
+                (
+                    self.event_page.page_ptr,
+                    {f"carousel_items.{self.carousel_items[3].pk}.link_document"},
+                )
+            ],
+        }
+
+        self.assertEqual(
+            {
+                item: [
+                    (ref_group[0], {ref.content_path for ref in ref_group[1]})
+                    for ref_group in ref_groups
+                ]
+                for item, ref_groups in refs.items()
+            },
+            expected_refs,
+        )

wagtail/tests/test_revision_model.py

@@ -7,6 +7,7 @@ from freezegun import freeze_time
 from wagtail.models import Page, Revision, get_default_page_content_type
 from wagtail.test.testapp.models import (
     FullFeaturedSnippet,
+    RevisableChildModel,
     RevisableGrandChildModel,
     RevisableModel,
     SimplePage,
@@ -90,17 +91,32 @@ class TestRevisableModel(TestCase):
         self.assertEqual(instance.get_base_content_type(), base_content_type)
         self.assertEqual(instance.get_content_type(), content_type)
 
-        # The for_instance() method should return the revision,
-        # whether we're using the specific instance
+        # The `for_instance()` method of `Revision.objects` and the model's
+        # `revisions` property should return the revision,
+        # whether we're using the most specific instance
         self.assertIsInstance(instance, RevisableModel)
+        self.assertIsInstance(instance, RevisableChildModel)
         self.assertIsInstance(instance, RevisableGrandChildModel)
         self.assertEqual(Revision.objects.for_instance(instance).first(), revision)
+        self.assertEqual(instance.revisions.first(), revision)
+
+        # the intermediary instance
+        intermediary_instance = RevisableChildModel.objects.get(pk=instance.pk)
+        self.assertIsInstance(intermediary_instance, RevisableModel)
+        self.assertIsInstance(intermediary_instance, RevisableChildModel)
+        self.assertNotIsInstance(intermediary_instance, RevisableGrandChildModel)
+        self.assertEqual(
+            Revision.objects.for_instance(intermediary_instance).first(),
+            revision,
+        )
+        self.assertEqual(intermediary_instance.revisions.first(), revision)
 
         # or the base instance
         base_instance = RevisableModel.objects.get(pk=instance.pk)
         self.assertIsInstance(base_instance, RevisableModel)
         self.assertNotIsInstance(base_instance, RevisableGrandChildModel)
         self.assertEqual(Revision.objects.for_instance(base_instance).first(), revision)
+        self.assertEqual(base_instance.revisions.first(), revision)
 
     def test_content_type_for_page_model(self):
         hello_page = self.create_page()
@@ -119,17 +135,20 @@ class TestRevisableModel(TestCase):
         self.assertEqual(hello_page.get_base_content_type(), base_content_type)
         self.assertEqual(hello_page.get_content_type(), content_type)
 
-        # The for_instance() method should return the revision,
+        # The `for_instance()` method of `Revision.objects` and the model's
+        # `revisions` property should return the revision,
         # whether we're using the specific instance
         self.assertIsInstance(hello_page, SimplePage)
         self.assertIsInstance(hello_page, Page)
         self.assertEqual(Revision.objects.for_instance(hello_page).first(), revision)
+        self.assertEqual(hello_page.revisions.first(), revision)
 
         # or the base instance
         base_instance = Page.objects.get(pk=hello_page.pk)
         self.assertIsInstance(base_instance, Page)
         self.assertNotIsInstance(base_instance, SimplePage)
         self.assertEqual(Revision.objects.for_instance(base_instance).first(), revision)
+        self.assertEqual(base_instance.revisions.first(), revision)
 
     def test_as_object(self):
         self.instance.text = "updated"
@@ -200,15 +219,15 @@ class TestRevisableModel(TestCase):
     def test_revision_cascade_on_object_delete(self):
         page = self.create_page()
         full_featured_snippet = FullFeaturedSnippet.objects.create(text="foo")
+        # The RevisionMixin should provide a default `GenericRelation` so that
+        # revisions are deleted when the object is deleted, even if the
+        # model does not explicitly define a `GenericRelation` to `Revision`.
         cases = [
-            # Tuple of (instance, cascades)
-            # For models that define a GenericRelation to Revision, the revision
-            # should be deleted when the instance is deleted.
-            (page, True),
-            (full_featured_snippet, True),
-            (self.instance, False),  # No GenericRelation to Revision
+            page,
+            full_featured_snippet,
+            self.instance,  # No explicit GenericRelation to Revision
         ]
-        for instance, cascades in cases:
+        for instance in cases:
             with self.subTest(instance=instance):
                 revision = instance.save_revision()
                 query = {
@@ -217,4 +236,4 @@ class TestRevisableModel(TestCase):
                 }
                 self.assertEqual(Revision.objects.filter(**query).first(), revision)
                 instance.delete()
-                self.assertIs(Revision.objects.filter(**query).exists(), not cascades)
+                self.assertIs(Revision.objects.filter(**query).exists(), False)

wagtail/tests/test_rich_text.py

@@ -6,7 +6,12 @@ from django.utils import translation
 
 from wagtail.fields import RichTextField
 from wagtail.models import Locale, Page, Site
-from wagtail.rich_text import RichText, RichTextMaxLengthValidator, expand_db_html
+from wagtail.rich_text import (
+    RichText,
+    RichTextMaxLengthValidator,
+    RichTextMinLengthValidator,
+    expand_db_html,
+)
 from wagtail.rich_text.feature_registry import FeatureRegistry
 from wagtail.rich_text.pages import PageLinkHandler
 from wagtail.rich_text.rewriters import LinkRewriter, extract_attrs
@@ -414,24 +419,33 @@ class TestRichTextField(TestCase):
         )
 
 
-class TestRichTextMaxLengthValidator(TestCase):
+class TestRichTextLengthValidators(TestCase):
     def test_count_characters(self):
-        """Keep those tests up-to-date with MaxLength tests client-side."""
-        validator = RichTextMaxLengthValidator(50)
-        self.assertEqual(validator.clean("<p>Plain text</p>"), 10)
-        # HTML entities should be un-escaped.
-        self.assertEqual(validator.clean("<p>There&#x27;s quote</p>"), 13)
-        # BR should be ignored.
-        self.assertEqual(validator.clean("<p>Line<br/>break</p>"), 9)
-        # Content over multiple blocks should be treated as a single line of text with no joiner.
-        self.assertEqual(validator.clean("<p>Multi</p><p>blocks</p>"), 11)
-        # Empty blocks should be ignored.
-        self.assertEqual(validator.clean("<p>Empty</p><p></p><p>blocks</p>"), 11)
-        # HR should be ignored.
-        self.assertEqual(validator.clean("<p>With</p><hr/><p>HR</p>"), 6)
-        # Embed blocks should be ignored.
-        self.assertEqual(validator.clean("<p>With</p><embed/><p>embed</p>"), 9)
-        # Counts symbols with multiple code units (heart unicode + variation selector).
-        self.assertEqual(validator.clean("<p>U+2764 U+FE0F ❤️</p>"), 16)
-        # Counts symbols with zero-width joiners.
-        self.assertEqual(validator.clean("<p>👨‍👨‍👧</p>"), 5)
+        """Keep these tests up-to-date with RichText length tests client-side."""
+
+        validators = [
+            RichTextMaxLengthValidator(50),
+            RichTextMinLengthValidator(5),
+        ]
+
+        for validator in validators:
+            with self.subTest(validator=validator):
+                self.assertEqual(validator.clean("<p>Plain text</p>"), 10)
+                # HTML entities should be un-escaped.
+                self.assertEqual(validator.clean("<p>There&#x27;s quote</p>"), 13)
+                # BR should be ignored.
+                self.assertEqual(validator.clean("<p>Line<br/>break</p>"), 9)
+                # Content over multiple blocks should be treated as a single line of text with no joiner.
+                self.assertEqual(validator.clean("<p>Multi</p><p>blocks</p>"), 11)
+                # Empty blocks should be ignored.
+                self.assertEqual(
+                    validator.clean("<p>Empty</p><p></p><p>blocks</p>"), 11
+                )
+                # HR should be ignored.
+                self.assertEqual(validator.clean("<p>With</p><hr/><p>HR</p>"), 6)
+                # Embed blocks should be ignored.
+                self.assertEqual(validator.clean("<p>With</p><embed/><p>embed</p>"), 9)
+                # Counts symbols with multiple code units (heart unicode + variation selector).
+                self.assertEqual(validator.clean("<p>U+2764 U+FE0F ❤️</p>"), 16)
+                # Counts symbols with zero-width joiners.
+                self.assertEqual(validator.clean("<p>👨‍👨‍👧</p>"), 5)

wagtail/tests/test_streamfield.py

@@ -1200,3 +1200,17 @@ class TestDeconstructStreamFieldWithLookup(TestCase):
                 },
             },
         )
+
+
+class TestBlockTypeValidation(TestCase):
+    def test_non_streamblock_raises_correct_error(self):
+        """stream_block raises useful error message when non-StreamBlock is provided."""
+        msg = (
+            "The top-level block must be a StreamBlock (got StructBlock). "
+            "Either pass a StreamBlock instance/class, or a list of block definitions "
+            "as (name, block) tuples."
+        )
+
+        with self.assertRaisesMessage(TypeError, msg):
+            field = StreamField(blocks.StructBlock([("name", blocks.CharBlock())]))
+            field.stream_block