wagtail 6.2.2__py3-none-any.whl → 6.3__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,423 @@ 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_bulk_to_python_with_empty_list(self):
+        block = ImageBlock(required=False)
+        result = block.bulk_to_python([])
+        self.assertEqual(result, [])
+
+    def test_bulk_to_python_with_list_of_ints(self):
+        block = ImageBlock(required=False)
+        result = block.bulk_to_python([None, self.image.id, self.image.id])
+        self.assertEqual(result, [None, self.image, self.image])
+
+    def test_bulk_to_python_with_list_of_dicts(self):
+        block = ImageBlock(required=False)
+        result = block.bulk_to_python(
+            [
+                # This is the representation of a non-required ImageBlock left blank,
+                # as per test_get_prep_value_for_null_value
+                {"image": None, "alt_text": None, "decorative": None},
+                {
+                    "image": self.image.id,
+                    "alt_text": "Custom alt text",
+                    "decorative": False,
+                },
+                {
+                    "image": self.image.id,
+                    "alt_text": "Different alt text",
+                    "decorative": False,
+                },
+            ]
+        )
+        self.assertEqual(len(result), 3)
+        self.assertIsNone(result[0])
+        self.assertEqual(result[1].id, self.image.id)
+        self.assertEqual(result[1].contextual_alt_text, "Custom alt text")
+        self.assertEqual(result[2].id, self.image.id)
+        self.assertEqual(result[2].contextual_alt_text, "Different alt text")
+
+    def test_get_prep_value(self):
+        block = ImageBlock()
+
+        self.image.contextual_alt_text = "Custom alt text"
+        self.image.decorative = False
+
+        value = block.get_prep_value(self.image)
+        self.assertEqual(
+            value,
+            {
+                "image": self.image.id,
+                "alt_text": "Custom alt text",
+                "decorative": False,
+            },
+        )
+
+    def test_get_prep_value_for_null_value(self):
+        block = ImageBlock(required=False)
+
+        value = block.get_prep_value(None)
+        self.assertEqual(
+            value,
+            {"image": None, "alt_text": None, "decorative": None},
+        )
+
+    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()