wagtail 6.2.2__py3-none-any.whl → 6.3rc1__py3-none-any.whl

wagtail/images/tests/test_blocks.py

@@ -2,8 +2,15 @@ import unittest.mock
 
 from django.apps import apps
 from django.test import TestCase
+from django.utils.safestring import SafeString
 
-from wagtail.images.blocks import ImageChooserBlock
+from wagtail.admin import compare
+from wagtail.blocks.stream_block import StreamValue
+from wagtail.blocks.struct_block import StructBlockValidationError
+from wagtail.images.blocks import ImageBlock, ImageChooserBlock
+from wagtail.telepath import JSContext
+from wagtail.test.testapp.models import StreamPage
+from wagtail.test.utils.wagtail_tests import WagtailTestUtils
 
 from .utils import (
     Image,
@@ -73,3 +80,362 @@ class TestImageChooserBlock(TestCase):
 
         # None should not yield any references
         self.assertListEqual(list(block.extract_references(None)), [])
+
+
+class TestImageChooserBlockComparison(TestCase):
+    comparison_class = compare.StreamFieldComparison
+
+    def setUp(self):
+        self.image_1 = Image.objects.create(
+            title="Test image 1",
+            file=get_test_image_file(),
+        )
+
+        self.image_2 = Image.objects.create(
+            title="Test image 2",
+            file=get_test_image_file(),
+        )
+
+        self.field = StreamPage._meta.get_field("body")
+
+    def test_hasnt_changed(self):
+        field = StreamPage._meta.get_field("body")
+
+        comparison = self.comparison_class(
+            field,
+            StreamPage(
+                body=StreamValue(
+                    field.stream_block,
+                    [
+                        ("image", self.image_1, "1"),
+                    ],
+                )
+            ),
+            StreamPage(
+                body=StreamValue(
+                    field.stream_block,
+                    [
+                        ("image", self.image_1, "1"),
+                    ],
+                )
+            ),
+        )
+
+        self.assertTrue(comparison.is_field)
+        self.assertFalse(comparison.is_child_relation)
+        self.assertEqual(comparison.field_label(), "Body")
+        htmldiff = comparison.htmldiff()
+        self.assertIsInstance(htmldiff, SafeString)
+        self.assertIn('class="comparison__child-object"', htmldiff)
+        self.assertIn('class="preview-image"', htmldiff)
+        self.assertNotIn("deletion", htmldiff)
+        self.assertNotIn("addition", htmldiff)
+        self.assertFalse(comparison.has_changed())
+
+    def test_has_changed(self):
+        field = StreamPage._meta.get_field("body")
+
+        comparison = self.comparison_class(
+            field,
+            StreamPage(
+                body=StreamValue(
+                    field.stream_block,
+                    [
+                        ("image", self.image_1, "1"),
+                    ],
+                )
+            ),
+            StreamPage(
+                body=StreamValue(
+                    field.stream_block,
+                    [
+                        ("image", self.image_2, "1"),
+                    ],
+                )
+            ),
+        )
+
+        self.assertTrue(comparison.is_field)
+        self.assertFalse(comparison.is_child_relation)
+        self.assertEqual(comparison.field_label(), "Body")
+        htmldiff = comparison.htmldiff()
+        self.assertIsInstance(htmldiff, SafeString)
+        self.assertIn('class="comparison__child-object"', htmldiff)
+        self.assertIn('class="preview-image deletion"', htmldiff)
+        self.assertIn('class="preview-image addition"', htmldiff)
+        self.assertTrue(comparison.has_changed())
+
+
+class TestImageBlock(TestImageChooserBlock):
+    def test_render(self):
+        block = ImageBlock()
+        value = {
+            "image": self.image.id,  # An id is expected
+            "alt_text": "Sample alt text",
+            "decorative": False,
+        }
+        html = block.render(block.to_python(value))
+        soup = WagtailTestUtils.get_soup(html)
+        img_tag = soup.find("img")
+
+        # check specific attributes
+        self.assertEqual(img_tag["alt"], value.get("alt_text"))
+        self.assertIn("/media/images/test", img_tag["src"])
+
+    def test_render_basic(self):
+        block = ImageBlock()
+        value = {
+            "image": self.image.id,  # An id is expected
+            "alt_text": "Sample alt text",
+            "decorative": False,
+        }
+        html = block.render_basic(block.to_python(value))
+        soup = WagtailTestUtils.get_soup(html)
+        img_tag = soup.find("img")
+
+        # check specific attributes
+        self.assertEqual(img_tag["alt"], value.get("alt_text"))
+        self.assertIn("/media/images/test", img_tag["src"])
+
+    def test_render_as_decorative(self):
+        block = ImageBlock()
+        value = {
+            "image": self.image.id,  # An id is expected
+            "alt_text": "Sample alt text",
+            "decorative": True,
+        }
+        html = block.render(block.to_python(value))
+        soup = WagtailTestUtils.get_soup(html)
+        img_tag = soup.find("img")
+
+        # check specific attributes
+        self.assertEqual(img_tag["alt"], "")
+        self.assertIn("/media/images/test", img_tag["src"])
+
+    def test_no_alt_text(self):
+        block = ImageBlock()
+        value = {
+            "image": self.image.id,  # An id is expected
+            "alt_text": None,  # No alt text passed
+            "decorative": False,
+        }
+
+        # Invalid state when no alt text is given, and image not marked as decorative
+        # Should raise a StructBlock validation error
+        with self.assertRaises(StructBlockValidationError) as context:
+            block.clean(block.to_python(value))
+
+        # Check the error message
+        self.assertIn(
+            "Please add some alt text for your image or mark it as decorative",
+            str(context.exception.block_errors["alt_text"]),
+        )
+
+    def test_to_python_with_int(self):
+        block = ImageBlock()
+        value = block.to_python(self.image.id)
+
+        self.assertEqual(value.id, self.image.id)
+        self.assertEqual(value.contextual_alt_text, None)
+        self.assertFalse(value.decorative)
+
+    def test_to_python_with_dict(self):
+        block = ImageBlock()
+        value = {"image": self.image.id, "alt_text": "Sample text", "decorative": False}
+        result = block.to_python(value)
+
+        self.assertEqual(result.id, self.image.id)
+        self.assertEqual(result.contextual_alt_text, "Sample text")
+        self.assertFalse(result.decorative)
+
+    def test_get_searchable_content(self):
+        block = ImageBlock()
+        value = {
+            "image": self.image.id,  # An id is expected
+            "alt_text": "Sample alt text",
+            "decorative": False,
+        }
+        result = block.get_searchable_content(block.to_python(value))
+
+        # check specific attributes
+        self.assertEqual(result, ["Sample alt text"])
+
+    def test_required_true(self):
+        block = ImageBlock()
+
+        # the inner ImageChooserBlock should appear as required
+        image_block_def = JSContext().pack(block)
+        image_chooser_block_def = image_block_def["_args"][1][0]
+        self.assertTrue(image_chooser_block_def["_args"][2]["required"])
+
+        value = block.to_python(
+            {
+                "image": None,
+                "alt_text": "",
+                "decorative": False,
+            }
+        )
+        with self.assertRaises(StructBlockValidationError) as context:
+            block.clean(value)
+
+        self.assertIn(
+            "This field is required",
+            str(context.exception.block_errors["image"]),
+        )
+
+    def test_required_false(self):
+        block = ImageBlock(required=False)
+
+        # the inner ImageChooserBlock should appear as non-required
+        image_block_def = JSContext().pack(block)
+        image_chooser_block_def = image_block_def["_args"][1][0]
+        self.assertFalse(image_chooser_block_def["_args"][2]["required"])
+
+        value = block.to_python(
+            {
+                "image": None,
+                "alt_text": "",
+                "decorative": False,
+            }
+        )
+        self.assertIsNone(block.clean(value))
+
+
+class TestImageBlockComparison(TestCase):
+    comparison_class = compare.StreamFieldComparison
+
+    def setUp(self):
+        self.image_1 = Image.objects.create(
+            title="Test image 1",
+            file=get_test_image_file(),
+        )
+
+        self.image_2 = Image.objects.create(
+            title="Test image 2",
+            file=get_test_image_file(),
+        )
+
+        self.field = StreamPage._meta.get_field("body")
+
+    def test_hasnt_changed(self):
+        field = StreamPage._meta.get_field("body")
+
+        page_1 = StreamPage()
+        page_1.body = [
+            {
+                "type": "image_with_alt",
+                "value": {
+                    "image": self.image_1.id,
+                    "decorative": False,
+                    "alt_text": "Some alt text",
+                },
+                "id": "1",
+            },
+        ]
+        page_2 = StreamPage()
+        page_2.body = [
+            {
+                "type": "image_with_alt",
+                "value": {
+                    "image": self.image_1.id,
+                    "decorative": False,
+                    "alt_text": "Some alt text",
+                },
+                "id": "1",
+            },
+        ]
+
+        comparison = self.comparison_class(field, page_1, page_2)
+
+        self.assertTrue(comparison.is_field)
+        self.assertFalse(comparison.is_child_relation)
+        self.assertEqual(comparison.field_label(), "Body")
+        htmldiff = comparison.htmldiff()
+        self.assertIsInstance(htmldiff, SafeString)
+        self.assertIn('class="comparison__child-object"', htmldiff)
+        self.assertIn('class="preview-image"', htmldiff)
+        self.assertNotIn("deletion", htmldiff)
+        self.assertNotIn("addition", htmldiff)
+        self.assertFalse(comparison.has_changed())
+
+    def test_has_changed(self):
+        field = StreamPage._meta.get_field("body")
+
+        page_1 = StreamPage()
+        page_1.body = [
+            {
+                "type": "image_with_alt",
+                "value": {
+                    "image": self.image_1.id,
+                    "decorative": False,
+                    "alt_text": "Some alt text",
+                },
+                "id": "1",
+            },
+        ]
+        page_2 = StreamPage()
+        page_2.body = [
+            {
+                "type": "image_with_alt",
+                "value": {
+                    "image": self.image_2.id,
+                    "decorative": False,
+                    "alt_text": "Some alt text",
+                },
+                "id": "1",
+            },
+        ]
+
+        comparison = self.comparison_class(field, page_1, page_2)
+
+        self.assertTrue(comparison.is_field)
+        self.assertFalse(comparison.is_child_relation)
+        self.assertEqual(comparison.field_label(), "Body")
+        htmldiff = comparison.htmldiff()
+        self.assertIsInstance(htmldiff, SafeString)
+        self.assertIn('class="comparison__child-object"', htmldiff)
+        self.assertIn('class="preview-image deletion"', htmldiff)
+        self.assertIn('class="preview-image addition"', htmldiff)
+        self.assertTrue(comparison.has_changed())
+
+    def test_alt_text_has_changed(self):
+        field = StreamPage._meta.get_field("body")
+
+        page_1 = StreamPage()
+        page_1.body = [
+            {
+                "type": "image_with_alt",
+                "value": {
+                    "image": self.image_1.id,
+                    "decorative": False,
+                    "alt_text": "a cat playing with some string",
+                },
+                "id": "1",
+            },
+        ]
+        page_2 = StreamPage()
+        page_2.body = [
+            {
+                "type": "image_with_alt",
+                "value": {
+                    "image": self.image_1.id,
+                    "decorative": False,
+                    "alt_text": "a kitten playing with some string",
+                },
+                "id": "1",
+            },
+        ]
+
+        comparison = self.comparison_class(field, page_1, page_2)
+
+        self.assertTrue(comparison.is_field)
+        self.assertFalse(comparison.is_child_relation)
+        self.assertEqual(comparison.field_label(), "Body")
+        htmldiff = comparison.htmldiff()
+        self.assertIsInstance(htmldiff, SafeString)
+        self.assertIn('class="comparison__child-object"', htmldiff)
+        self.assertIn(
+            '<dd>a <span class="deletion">cat</span><span class="addition">kitten</span> playing with some string</dd>',
+            htmldiff,
+        )
+        self.assertTrue(comparison.has_changed())

wagtail/images/tests/test_image_operations.py

@@ -719,6 +719,29 @@ class TestFormatFilter(TestCase):
         # quality=80 is default for the Willow and PIL libraries
         save.assert_called_with(f, "WEBP", quality=80, lossless=True)
 
+    def test_heic(self):
+        fil = Filter(spec="width-400|format-heic")
+        image = Image.objects.create(
+            title="Test image",
+            file=get_test_image_file(),
+        )
+        out = fil.run(image, BytesIO())
+
+        self.assertEqual(out.format_name, "heic")
+
+    def test_heic_lossless(self):
+        fil = Filter(spec="width-400|format-heic-lossless")
+        image = Image.objects.create(
+            title="Test image",
+            file=get_test_image_file(),
+        )
+
+        f = BytesIO()
+        with patch("PIL.Image.Image.save") as save:
+            fil.run(image, f)
+
+        save.assert_called_with(f, "HEIF", quality=-1, chroma=444)
+
     def test_invalid(self):
         fil = Filter(spec="width-400|format-foo")
         image = Image.objects.create(

wagtail/images/tests/test_models.py

@@ -145,6 +145,23 @@ class TestImage(TestCase):
         )
         self.assertIsNone(image.get_suggested_focal_point())
 
+    def test_default_with_description(self):
+        # Primary default should be description
+        image = Image.objects.create(
+            title="Test Image",
+            description="This is a test description",
+            file=get_test_image_file(),
+        )
+        self.assertEqual(image.default_alt_text, image.description)
+
+    def test_default_without_description(self):
+        # Secondary default should be title
+        image = Image.objects.create(
+            title="Test Image",
+            file=get_test_image_file(),
+        )
+        self.assertEqual(image.default_alt_text, image.title)
+
 
 class TestImageQuerySet(TransactionTestCase):
     fixtures = ["test_empty.json"]
@@ -787,6 +804,9 @@ class TestRenditions(TestCase):
             prefetched_rendition = fresh_image.get_rendition("width-500")
         self.assertFalse(hasattr(prefetched_rendition, "_mark"))
 
+        # Check that the image instance is the same as the retrieved rendition
+        self.assertIs(new_rendition.image, self.image)
+
         # changing the image file should invalidate the cache
         self.image.file = get_test_image_file(colour="green")
         self.image.save()

wagtail/images/tests/test_signal_handlers.py

@@ -1,95 +1,99 @@
-from django.db import transaction
-from django.test import TestCase, TransactionTestCase, override_settings
-
-from wagtail.images import get_image_model, signal_handlers
-from wagtail.images.tests.utils import get_test_image_file
-from wagtail.models import Collection
-
-from .utils import Image
-
-
-class TestFilesDeletedForDefaultModels(TransactionTestCase):
-    """
-    Because we expect file deletion to only happen once a transaction is
-    successfully committed, we must run these tests using TransactionTestCase
-    per the following documentation:
-
-        Django's TestCase class wraps each test in a transaction and rolls back that
-        transaction after each test, in order to provide test isolation. This means
-        that no transaction is ever actually committed, thus your on_commit()
-        callbacks will never be run. If you need to test the results of an
-        on_commit() callback, use a TransactionTestCase instead.
-        https://docs.djangoproject.com/en/1.10/topics/db/transactions/#use-in-tests
-    """
-
-    def setUp(self):
-        # Required to create root collection because the TransactionTestCase
-        # does not make initial data loaded in migrations available and
-        # serialized_rollback=True causes other problems in the test suite.
-        # ref: https://docs.djangoproject.com/en/1.10/topics/testing/overview/#rollback-emulation
-        Collection.objects.get_or_create(
-            name="Root",
-            path="0001",
-            depth=1,
-            numchild=0,
-        )
-
-    def test_image_file_deleted_oncommit(self):
-        with transaction.atomic():
-            image = get_image_model().objects.create(
-                title="Test Image", file=get_test_image_file()
-            )
-            filename = image.file.name
-            self.assertTrue(image.file.storage.exists(filename))
-            image.delete()
-            self.assertTrue(image.file.storage.exists(filename))
-        self.assertFalse(image.file.storage.exists(filename))
-
-    def test_rendition_file_deleted_oncommit(self):
-        with transaction.atomic():
-            image = get_image_model().objects.create(
-                title="Test Image", file=get_test_image_file()
-            )
-            rendition = image.get_rendition("original")
-            filename = rendition.file.name
-            self.assertTrue(rendition.file.storage.exists(filename))
-            rendition.delete()
-            self.assertTrue(rendition.file.storage.exists(filename))
-        self.assertFalse(rendition.file.storage.exists(filename))
-
-
-@override_settings(WAGTAILIMAGES_IMAGE_MODEL="tests.CustomImage")
-class TestFilesDeletedForCustomModels(TestFilesDeletedForDefaultModels):
-    def setUp(self):
-        # Required to create root collection because the TransactionTestCase
-        # does not make initial data loaded in migrations available and
-        # serialized_rollback=True causes other problems in the test suite.
-        # ref: https://docs.djangoproject.com/en/1.10/topics/testing/overview/#rollback-emulation
-        Collection.objects.get_or_create(
-            name="Root",
-            path="0001",
-            depth=1,
-            numchild=0,
-        )
-
-        #: Sadly signal receivers only get connected when starting django.
-        #: We will re-attach them here to mimic the django startup behaviour
-        #: and get the signals connected to our custom model..
-        signal_handlers.register_signal_handlers()
-
-    def test_image_model(self):
-        cls = get_image_model()
-        self.assertEqual(f"{cls._meta.app_label}.{cls.__name__}", "tests.CustomImage")
-
-
-@override_settings(WAGTAILIMAGES_FEATURE_DETECTION_ENABLED=True)
-class TestRawForPreSaveImageFeatureDetection(TestCase):
-    fixtures = ["test.json"]
-
-    # just to test the file is from a fixture doesn't actually exists.
-    # raw check in pre_save_image_feature_detection skips on the provided condition of this test
-    # hence avoiding an error
-
-    def test_image_does_not_exist(self):
-        bad_image = Image.objects.get(pk=1)
-        self.assertFalse(bad_image.file.storage.exists(bad_image.file.name))
+from django.db import transaction
+from django.test import TestCase, TransactionTestCase, override_settings
+
+from wagtail.images import get_image_model, signal_handlers
+from wagtail.images.tests.utils import get_test_image_file
+from wagtail.models import Collection
+
+from .utils import Image
+
+
+class TestFilesDeletedForDefaultModels(TransactionTestCase):
+    """
+    Because we expect file deletion to only happen once a transaction is
+    successfully committed, we must run these tests using TransactionTestCase
+    per the following documentation:
+
+        Django's TestCase class wraps each test in a transaction and rolls back that
+        transaction after each test, in order to provide test isolation. This means
+        that no transaction is ever actually committed, thus your on_commit()
+        callbacks will never be run. If you need to test the results of an
+        on_commit() callback, use a TransactionTestCase instead.
+        https://docs.djangoproject.com/en/1.10/topics/db/transactions/#use-in-tests
+    """
+
+    def setUp(self):
+        # Required to create root collection because the TransactionTestCase
+        # does not make initial data loaded in migrations available and
+        # serialized_rollback=True causes other problems in the test suite.
+        # ref: https://docs.djangoproject.com/en/1.10/topics/testing/overview/#rollback-emulation
+        Collection.objects.get_or_create(
+            name="Root",
+            path="0001",
+            depth=1,
+            numchild=0,
+        )
+
+    def test_image_file_deleted_oncommit(self):
+        with transaction.atomic():
+            image = get_image_model().objects.create(
+                title="Test Image",
+                description="A test description",
+                file=get_test_image_file(),
+            )
+            filename = image.file.name
+            self.assertTrue(image.file.storage.exists(filename))
+            image.delete()
+            self.assertTrue(image.file.storage.exists(filename))
+        self.assertFalse(image.file.storage.exists(filename))
+
+    def test_rendition_file_deleted_oncommit(self):
+        with transaction.atomic():
+            image = get_image_model().objects.create(
+                title="Test Image",
+                description="A test description",
+                file=get_test_image_file(),
+            )
+            rendition = image.get_rendition("original")
+            filename = rendition.file.name
+            self.assertTrue(rendition.file.storage.exists(filename))
+            rendition.delete()
+            self.assertTrue(rendition.file.storage.exists(filename))
+        self.assertFalse(rendition.file.storage.exists(filename))
+
+
+@override_settings(WAGTAILIMAGES_IMAGE_MODEL="tests.CustomImage")
+class TestFilesDeletedForCustomModels(TestFilesDeletedForDefaultModels):
+    def setUp(self):
+        # Required to create root collection because the TransactionTestCase
+        # does not make initial data loaded in migrations available and
+        # serialized_rollback=True causes other problems in the test suite.
+        # ref: https://docs.djangoproject.com/en/1.10/topics/testing/overview/#rollback-emulation
+        Collection.objects.get_or_create(
+            name="Root",
+            path="0001",
+            depth=1,
+            numchild=0,
+        )
+
+        #: Sadly signal receivers only get connected when starting django.
+        #: We will re-attach them here to mimic the django startup behaviour
+        #: and get the signals connected to our custom model..
+        signal_handlers.register_signal_handlers()
+
+    def test_image_model(self):
+        cls = get_image_model()
+        self.assertEqual(f"{cls._meta.app_label}.{cls.__name__}", "tests.CustomImage")
+
+
+@override_settings(WAGTAILIMAGES_FEATURE_DETECTION_ENABLED=True)
+class TestRawForPreSaveImageFeatureDetection(TestCase):
+    fixtures = ["test.json"]
+
+    # just to test the file is from a fixture doesn't actually exists.
+    # raw check in pre_save_image_feature_detection skips on the provided condition of this test
+    # hence avoiding an error
+
+    def test_image_does_not_exist(self):
+        bad_image = Image.objects.get(pk=1)
+        self.assertFalse(bad_image.file.storage.exists(bad_image.file.name))

wagtail/images/tests/test_site_summary.py

@@ -126,9 +126,9 @@ class TestImagesSummary(WagtailTestUtils, TestCase):
 
     def test_user_sees_proper_image_count(self):
         cases = (
-            (self.superuser, "<span>3</span> Images"),
-            (self.bird_adder, "<span>2</span> Images"),
-            (self.bird_chooser, "<span>2</span> Images"),
+            (self.superuser, "3 Images"),
+            (self.bird_adder, "2 Images"),
+            (self.bird_chooser, "2 Images"),
         )
         for user, content in cases:
             with self.subTest(user=user):