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

wagtail/images/tests/test_bulk_actions/test_bulk_delete.py

@@ -1,9 +1,11 @@
 from django.contrib.auth.models import Permission
 from django.test import TestCase
 from django.urls import reverse
+from django.utils.http import urlencode
 
 from wagtail.images import get_image_model
 from wagtail.images.tests.utils import get_test_image_file
+from wagtail.test.testapp.models import VariousOnDeleteModel
 from wagtail.test.utils import WagtailTestUtils
 
 Image = get_image_model()
@@ -11,27 +13,24 @@ test_file = get_test_image_file()
 
 
 class TestImageBulkDeleteView(WagtailTestUtils, TestCase):
-    def setUp(self):
-        self.user = self.login()
-
-        # Create images to delete
-        self.images = [
+    @classmethod
+    def setUpTestData(cls):
+        cls.images = [
             Image.objects.create(title=f"Test image - {i}", file=test_file)
             for i in range(1, 6)
         ]
-        self.url = (
-            reverse(
-                "wagtail_bulk_action",
-                args=(
-                    "wagtailimages",
-                    "image",
-                    "delete",
-                ),
-            )
-            + "?"
+        cls.url = reverse(
+            "wagtail_bulk_action",
+            args=(Image._meta.app_label, Image._meta.model_name, "delete"),
         )
-        for image in self.images:
-            self.url += f"id={image.id}&"
+        cls.query_params = {
+            "next": reverse("wagtailimages:index"),
+            "id": [item.pk for item in cls.images],
+        }
+        cls.url += "?" + urlencode(cls.query_params, doseq=True)
+
+    def setUp(self):
+        self.user = self.login()
 
     def test_delete_with_limited_permissions(self):
         self.user.is_superuser = False
@@ -88,4 +87,52 @@ class TestImageBulkDeleteView(WagtailTestUtils, TestCase):
         for image in self.images:
             self.assertContains(response, image.usage_url)
         # usage count should be printed for each image
-        self.assertContains(response, "Used 0 times", count=5)
+        self.assertContains(response, "This image is referenced 0 times.", count=5)
+
+    def test_delete_get_with_protected_reference(self):
+        protected = self.images[0]
+        with self.captureOnCommitCallbacks(execute=True):
+            VariousOnDeleteModel.objects.create(
+                text="Undeletable",
+                protected_image=protected,
+            )
+        response = self.client.get(self.url)
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        main = soup.select_one("main")
+        usage_link = main.find(
+            "a",
+            href=reverse("wagtailimages:image_usage", args=[protected.pk])
+            + "?describe_on_delete=1",
+        )
+        self.assertIsNotNone(usage_link)
+        self.assertEqual(usage_link.text.strip(), "This image is referenced 1 time.")
+        self.assertContains(
+            response,
+            "One or more references to this image prevent it from being deleted.",
+        )
+        submit_button = main.select_one("form button[type=submit]")
+        self.assertIsNone(submit_button)
+        back_button = main.find("a", href=reverse("wagtailimages:index"))
+        self.assertIsNotNone(back_button)
+        self.assertEqual(back_button.text.strip(), "Go back")
+
+    def test_delete_post_with_protected_reference(self):
+        protected = self.images[0]
+        with self.captureOnCommitCallbacks(execute=True):
+            VariousOnDeleteModel.objects.create(
+                text="Undeletable",
+                protected_image=protected,
+            )
+        response = self.client.post(self.url)
+
+        # Should throw a PermissionDenied error and redirect to the dashboard
+        self.assertEqual(response.status_code, 302)
+        self.assertRedirects(response, reverse("wagtailadmin_home"))
+        self.assertEqual(
+            response.context["message"],
+            "Sorry, you do not have permission to access this area.",
+        )
+
+        # Check that the image is still here
+        self.assertTrue(Image.objects.filter(pk=protected.pk).exists())

wagtail/images/tests/test_jinja2_svg.py

@@ -0,0 +1,240 @@
+from django.test import TestCase
+
+from wagtail.images.models import Image
+from wagtail.images.tests.utils import (
+    get_test_image_file,
+    get_test_image_file_svg,
+    get_test_image_filename,
+)
+from wagtail.test.utils import WagtailTestUtils
+
+
+class TestJinja2SVGSupport(WagtailTestUtils, TestCase):
+    """Test SVG support in Jinja2 templates with preserve-svg filter."""
+
+    def setUp(self):
+        # Create a real test engine
+        from django.template.loader import engines
+
+        self.engine = engines["jinja2"]
+
+        # Create a raster image
+        self.raster_image = Image.objects.create(
+            title="Test raster image",
+            file=get_test_image_file(),
+        )
+
+        # Create an SVG image
+        self.svg_image = Image.objects.create(
+            title="Test SVG image",
+            file=get_test_image_file_svg(),
+        )
+
+    def render(self, string, context=None):
+        if context is None:
+            context = {}
+
+        template = self.engine.from_string(string)
+        return template.render(context)
+
+    def test_image_with_raster_image(self):
+        """Test that raster images work normally without preserve-svg."""
+        html = self.render(
+            '{{ image(img, "width-200|format-webp") }}', {"img": self.raster_image}
+        )
+        filename = get_test_image_filename(self.raster_image, "width-200.format-webp")
+
+        self.assertHTMLEqual(
+            html,
+            f'<img src="{filename}" width="200" height="150" alt="Test raster image">',
+        )
+
+    def test_image_with_svg_without_preserve(self):
+        """Test that without preserve-svg, SVGs get all operations (which would fail in production)."""
+        with self.assertRaises(AttributeError):
+            self.render(
+                '{{ image(img, "width-200|format-webp") }}', {"img": self.svg_image}
+            )
+
+    def test_image_with_svg_with_preserve(self):
+        """Test that with preserve-svg filter, SVGs only get safe operations."""
+        html = self.render(
+            '{{ image(img, "width-45|format-webp|preserve-svg") }}',
+            {"img": self.svg_image},
+        )
+        filename = get_test_image_filename(self.svg_image, "width-45")
+
+        self.assertHTMLEqual(
+            html,
+            f'<img src="{filename}" width="45.0" height="45.0" alt="Test SVG image">',
+        )
+
+    def test_raster_image_with_preserve_svg(self):
+        """Test that preserve-svg on image tag has no effect on raster images."""
+        html = self.render(
+            '{{ image(img, "width-100|format-webp|preserve-svg") }}',
+            {"img": self.raster_image},
+        )
+        filename = get_test_image_filename(self.raster_image, "width-100.format-webp")
+
+        self.assertHTMLEqual(
+            html,
+            f'<img src="{filename}" width="100" height="75" alt="Test raster image">',
+        )
+
+    def test_srcset_image_with_svg_preserve(self):
+        """Test that preserve-svg works with srcset_image function."""
+        html = self.render(
+            '{{ srcset_image(img, "width-{35,55}|format-webp|preserve-svg", sizes="100vw") }}',
+            {"img": self.svg_image},
+        )
+        filename35 = get_test_image_filename(self.svg_image, "width-35")
+        filename55 = get_test_image_filename(self.svg_image, "width-55")
+
+        self.assertHTMLEqual(
+            html,
+            f"""
+                <img sizes="100vw" src="{filename35}"
+                    srcset="{filename35} 35.0w, {filename55} 55.0w" width="35.0" height="35.0"
+                    alt="Test SVG image">
+            """,
+        )
+
+    def test_raster_srcset_image_with_preserve_svg(self):
+        """Test that preserve-svg on srcset_image tag has no effect on raster images."""
+        html = self.render(
+            '{{ srcset_image(img, "width-{100,120}|format-webp|preserve-svg", sizes="100vw") }}',
+            {"img": self.raster_image},
+        )
+        filename100 = get_test_image_filename(
+            self.raster_image, "width-100.format-webp"
+        )
+        filename120 = get_test_image_filename(
+            self.raster_image, "width-120.format-webp"
+        )
+
+        self.assertHTMLEqual(
+            html,
+            f"""
+                <img sizes="100vw" src="{filename100}"
+                    srcset="{filename100} 100w, {filename120} 120w" width="100" height="75"
+                    alt="Test raster image">
+            """,
+        )
+
+    def test_picture_with_svg_preserve(self):
+        """Test that preserve-svg works with picture function."""
+        html = self.render(
+            '{{ picture(img, "format-{avif,webp,jpeg}|width-85|preserve-svg") }}',
+            {"img": self.svg_image},
+        )
+        filename = get_test_image_filename(self.svg_image, "width-85")
+        self.assertHTMLEqual(
+            html,
+            f"""
+                <picture>
+                    <img src="{filename}" alt="Test SVG image" width="85.0" height="85.0">
+                </picture>
+            """,
+        )
+
+    def test_raster_picture_with_preserve_svg(self):
+        """Test that preserve-svg on picture tag has no effect on raster images."""
+        html = self.render(
+            '{{ picture(img, "width-160|format-{webp,jpeg}|preserve-svg") }}',
+            {"img": self.raster_image},
+        )
+        filename_webp = get_test_image_filename(
+            self.raster_image, "width-160.format-webp"
+        )
+        filename_jpeg = get_test_image_filename(
+            self.raster_image, "width-160.format-jpeg"
+        )
+
+        self.assertHTMLEqual(
+            html,
+            f"""
+                <picture>
+                    <source srcset="{filename_webp}" type="image/webp">
+                    <img src="{filename_jpeg}" alt="Test raster image" width="160" height="120">
+                </picture>
+            """,
+        )
+
+    def test_preserve_svg_with_multiple_operations(self):
+        """Test preserve-svg with multiple operations, some safe, some unsafe for SVGs."""
+        html = self.render(
+            '{{ image(img, "width-300|height-200|format-webp|max-100x100|jpegquality-80|preserve-svg") }}',
+            {"img": self.svg_image},
+        )
+        filename = get_test_image_filename(
+            self.svg_image, "width-300.height-200.max-100x100"
+        )
+        self.assertHTMLEqual(
+            html,
+            f'<img src="{filename}" alt="Test SVG image" width="100.0" height="100.0">',
+        )
+
+    def test_preserve_svg_with_custom_attributes(self):
+        """Test preserve-svg works with custom HTML attributes."""
+        html = self.render(
+            '{{ image(img, "width-66|format-webp|preserve-svg", class="my-image", alt="Custom alt") }}',
+            {"img": self.svg_image},
+        )
+        filename = get_test_image_filename(self.svg_image, "width-66")
+
+        self.assertHTMLEqual(
+            html,
+            f'<img src="{filename}" class="my-image" alt="Custom alt" width="66.0" height="66.0">',
+        )
+
+    def test_picture_with_multiple_formats_and_sizes_with_raster_image(self):
+        filenames = [
+            get_test_image_filename(self.raster_image, "width-160.format-avif"),
+            get_test_image_filename(self.raster_image, "width-320.format-avif"),
+            get_test_image_filename(self.raster_image, "width-160.format-jpeg"),
+            get_test_image_filename(self.raster_image, "width-320.format-jpeg"),
+        ]
+
+        rendered = self.render(
+            '{{ picture(myimage, "width-{160,320}|format-{avif,jpeg}|preserve-svg", sizes="100vw") }}',
+            {"myimage": self.raster_image},
+        )
+        expected = f"""
+            <picture>
+            <source srcset="{filenames[0]} 160w, {filenames[1]} 320w" sizes="100vw" type="image/avif">
+            <img
+                sizes="100vw"
+                src="{filenames[2]}"
+                srcset="{filenames[2]} 160w, {filenames[3]} 320w"
+                alt="Test raster image"
+                width="160"
+                height="120"
+            >
+            </picture>
+        """
+        self.assertHTMLEqual(rendered, expected)
+
+    def test_picture_with_multiple_formats_and_sizes_with_svg_image(self):
+        filenames = [
+            get_test_image_filename(self.svg_image, "width-45"),
+            get_test_image_filename(self.svg_image, "width-90"),
+        ]
+
+        rendered = self.render(
+            '{{ picture(myimage, "width-{45,90}|format-{avif,jpeg}|preserve-svg", sizes="100vw") }}',
+            {"myimage": self.svg_image},
+        )
+        expected = f"""
+            <picture>
+            <img
+                sizes="100vw"
+                src="{filenames[0]}"
+                srcset="{filenames[0]} 45.0w, {filenames[1]} 90.0w"
+                alt="Test SVG image"
+                width="45.0"
+                height="45.0"
+            >
+            </picture>
+        """
+        self.assertHTMLEqual(rendered, expected)

wagtail/images/tests/test_models.py

@@ -14,6 +14,7 @@ from django.test import SimpleTestCase, TestCase, TransactionTestCase, override_
 from django.urls import reverse
 from willow.image import Image as WillowImage
 
+from wagtail.images.exceptions import InvalidFilterSpecError
 from wagtail.images.models import (
     Filter,
     Picture,
@@ -521,6 +522,10 @@ class TestRenditions(TestCase):
             title="Test image",
             file=get_test_image_file(),
         )
+        self.svg_image = Image.objects.create(
+            title="Test SVG image",
+            file=get_test_image_file_svg(),
+        )
 
     def test_get_rendition_model(self):
         self.assertIs(Image.get_rendition_model(), Rendition)
@@ -903,6 +908,10 @@ class TestRenditions(TestCase):
             rendition.background_position_style, "background-position: 15% 41%;"
         )
 
+        # Individual background position properties
+        self.assertEqual(rendition.background_position_x, "15%")
+        self.assertEqual(rendition.background_position_y, "41%")
+
     def test_background_position_style_default(self):
         # Generate a rendition that's half the size of the original
         rendition = self.image.get_rendition("width-320")
@@ -911,6 +920,10 @@ class TestRenditions(TestCase):
             rendition.background_position_style, "background-position: 50% 50%;"
         )
 
+        # Individual background position properties
+        self.assertEqual(rendition.background_position_x, "50%")
+        self.assertEqual(rendition.background_position_y, "50%")
+
     @override_settings()
     def test_rendition_storage_setting_absent(self):
         del settings.WAGTAILIMAGES_RENDITION_STORAGE
@@ -948,6 +961,107 @@ class TestRenditions(TestCase):
             get_rendition_storage(), storages[settings.WAGTAILIMAGES_RENDITION_STORAGE]
         )
 
+    def test_image_get_rendition_preserve_svg(self):
+        image_rendition_1 = self.image.get_rendition(
+            "width-400|bgcolor-000|format-jpeg|preserve-svg"
+        )
+        # no directives stripped except 'preserve-svg'
+        self.assertEqual(
+            image_rendition_1.filter_spec, "width-400|bgcolor-000|format-jpeg"
+        )
+
+        image_rendition_2 = self.image.get_rendition(
+            "width-400|bgcolor-000|format-jpeg"
+        )
+        # preserve-svg has no effect and thus the existing rendition will be returned
+        self.assertEqual(image_rendition_1, image_rendition_2)
+
+        # same behaviour when passing a Filter object rather than a string
+        image_rendition_3 = self.image.get_rendition(
+            Filter("width-400|bgcolor-000|format-jpeg|preserve-svg")
+        )
+        self.assertEqual(image_rendition_1, image_rendition_3)
+        image_rendition_4 = self.image.get_rendition(
+            Filter("width-400|bgcolor-000|format-jpeg")
+        )
+        self.assertEqual(image_rendition_1, image_rendition_4)
+
+        # preserve-svg with no other directive raises error
+        with self.assertRaises(InvalidFilterSpecError):
+            self.image.get_rendition("preserve-svg")
+
+    def test_svg_get_rendition_preserve_svg(self):
+        # rasterize directives stripped
+        svg_rendition_1 = self.svg_image.get_rendition(
+            "width-400|bgcolor-000|format-jpeg|preserve-svg"
+        )
+        self.assertEqual(svg_rendition_1.filter_spec, "width-400")
+
+        # str filter & Filter with preserve-svg produce same result
+        svg_rendition_2 = self.svg_image.get_rendition(
+            Filter("width-400|bgcolor-000|format-jpeg|preserve-svg")
+        )
+        self.assertEqual(svg_rendition_1, svg_rendition_2)
+
+        # fallback to 'original' if no SVG-safe directives remain
+        svg_rendition_3 = self.svg_image.get_rendition(
+            Filter("bgcolor-000|format-jpeg|preserve-svg")
+        )
+        self.assertEqual(svg_rendition_3.filter_spec, "original")
+
+        # no rasterize directives, no preserve-svg
+        svg_rendition_4 = self.svg_image.get_rendition(Filter("width-400"))
+        self.assertEqual(svg_rendition_4.filter_spec, "width-400")
+
+        # no rasterize directives, preserve-svg has no affect
+        svg_rendition_5 = self.svg_image.get_rendition(Filter("width-400|preserve-svg"))
+        self.assertEqual(svg_rendition_4, svg_rendition_5)
+
+        # has raterize directives but no preserve-svg raises error
+        with self.assertRaises(AttributeError):
+            self.svg_image.get_rendition(Filter("width-400|bgcolor-000|format-jpeg"))
+
+    def test_image_get_renditions_preserve_svg(self):
+        renditions = self.image.get_renditions(
+            "width-400|bgcolor-000|format-jpeg|preserve-svg",
+            "width-200|bgcolor-000|format-jpeg|preserve-svg",
+        )
+        filename1 = get_test_image_filename(
+            self.image, "width-400.bgcolor-000.format-jpeg"
+        )
+        filename2 = get_test_image_filename(
+            self.image, "width-200.bgcolor-000.format-jpeg"
+        )
+
+        # no directives stripped except 'preserve-svg'
+        # (which is stripped from both the dictionary key and the resulting rendition)
+        self.assertEqual(
+            renditions["width-400|bgcolor-000|format-jpeg"].filter_spec,
+            "width-400|bgcolor-000|format-jpeg",
+        )
+        self.assertEqual(renditions["width-400|bgcolor-000|format-jpeg"].url, filename1)
+
+        self.assertEqual(
+            renditions["width-200|bgcolor-000|format-jpeg"].filter_spec,
+            "width-200|bgcolor-000|format-jpeg",
+        )
+        self.assertEqual(renditions["width-200|bgcolor-000|format-jpeg"].url, filename2)
+
+    def test_svg_get_renditions_preserve_svg(self):
+        renditions = self.svg_image.get_renditions(
+            "width-400|bgcolor-000|format-jpeg|preserve-svg",
+            "width-200|bgcolor-000|format-jpeg|preserve-svg",
+        )
+        filename1 = get_test_image_filename(self.svg_image, "width-400")
+        filename2 = get_test_image_filename(self.svg_image, "width-200")
+
+        # all non-SVG-safe directives stripped (from both the dictionary key and the resulting rendition)
+        self.assertEqual(renditions["width-400"].filter_spec, "width-400")
+        self.assertEqual(renditions["width-400"].url, filename1)
+
+        self.assertEqual(renditions["width-200"].filter_spec, "width-200")
+        self.assertEqual(renditions["width-200"].url, filename2)
+
 
 @override_settings(
     CACHES={"default": {"BACKEND": "django.core.cache.backends.dummy.DummyCache"}}

wagtail/images/tests/test_templatetags.py

@@ -104,15 +104,18 @@ class ImageNodeTestCase(TestCase):
             (self.svg_image, ["height-300"], "height-300"),
             (self.svg_image, ["scale-50"], "scale-50"),
             (self.svg_image, ["fill-400x400"], "fill-400x400"),
+            (self.svg_image, ["format-webp", "webpquality-50"], "original"),
         ]
         for image, filter_specs, expected in params:
             with self.subTest(img=image, filter_specs=filter_specs, expected=expected):
                 context = {"image": image, "image_node": "fake_value"}
-                node = ImageNode(Variable("image"), filter_specs, preserve_svg=True)
-                node.render(context)
-                self.assertEqual(
-                    node.get_filter(preserve_svg=image.is_svg()).spec, expected
+                node = ImageNode(
+                    Variable("image"),
+                    filter_specs + ["preserve-svg"],
+                    output_var_name="rendition",
                 )
+                node.render(context)
+                self.assertEqual(context["rendition"].filter_spec, expected)
 
 
 class ImagesTestCase(TestCase):
@@ -482,3 +485,54 @@ class PictureTagTestCase(ImagesTestCase):
             </picture>
         """
         self.assertHTMLEqual(rendered, expected)
+
+    def test_preserve_svg_with_raster_image(self):
+        filenames = [
+            get_test_image_filename(self.image, "width-180.format-avif"),
+            get_test_image_filename(self.image, "width-360.format-avif"),
+            get_test_image_filename(self.image, "width-180.format-jpeg"),
+            get_test_image_filename(self.image, "width-360.format-jpeg"),
+        ]
+
+        rendered = self.render(
+            '{% picture myimage width-{180,360} format-{avif,jpeg} preserve-svg sizes="100vw" %}',
+            {"myimage": self.image},
+        )
+        expected = f"""
+            <picture>
+            <source srcset="{filenames[0]} 180w, {filenames[1]} 360w" sizes="100vw" type="image/avif">
+            <img
+                sizes="100vw"
+                src="{filenames[2]}"
+                srcset="{filenames[2]} 180w, {filenames[3]} 360w"
+                alt="Test image"
+                width="180"
+                height="135"
+            >
+            </picture>
+        """
+        self.assertHTMLEqual(rendered, expected)
+
+    def test_preserve_svg_with_svg_image(self):
+        filenames = [
+            get_test_image_filename(self.svg_image, "width-40"),
+            get_test_image_filename(self.svg_image, "width-80"),
+        ]
+
+        rendered = self.render(
+            '{% picture myimage width-{40,80} format-{avif,jpeg} preserve-svg sizes="100vw" %}',
+            {"myimage": self.svg_image},
+        )
+        expected = f"""
+            <picture>
+            <img
+                sizes="100vw"
+                src="{filenames[0]}"
+                srcset="{filenames[0]} 40.0w, {filenames[1]} 80.0w"
+                alt="Test SVG image"
+                width="40.0"
+                height="40.0"
+            >
+            </picture>
+        """
+        self.assertHTMLEqual(rendered, expected)

wagtail/images/utils.py

@@ -117,6 +117,7 @@ def to_svg_safe_spec(filter_specs):
     """
     if isinstance(filter_specs, str):
         filter_specs = filter_specs.split("|")
+
     svg_preserving_specs = [
         "max",
         "min",
@@ -126,9 +127,35 @@ def to_svg_safe_spec(filter_specs):
         "fill",
         "original",
     ]
+
+    # Keep only safe operations and remove preserve-svg
     safe_specs = [
         x
         for x in filter_specs
         if any(x.startswith(prefix) for prefix in svg_preserving_specs)
     ]
+
+    # If no safe operations remain, use 'original'
+    if not safe_specs:
+        return "original"
+
     return "|".join(safe_specs)
+
+
+def get_allowed_image_extensions():
+    return getattr(
+        settings,
+        "WAGTAILIMAGES_EXTENSIONS",
+        ["avif", "gif", "jpg", "jpeg", "png", "webp"],
+    )
+
+
+def get_accept_attributes():
+    allowed_image_extensions = get_allowed_image_extensions()
+    accept_attrs = "image/*"
+    if "heic" in allowed_image_extensions:
+        accept_attrs += ", image/heic"
+    if "avif" in allowed_image_extensions:
+        accept_attrs += ", image/avif"
+
+    return accept_attrs

wagtail/images/views/bulk_actions/delete.py

@@ -1,10 +1,11 @@
 from django.utils.translation import gettext_lazy as _
 from django.utils.translation import ngettext
 
+from wagtail.admin.views.bulk_action.mixins import ReferenceIndexMixin
 from wagtail.images.views.bulk_actions.image_bulk_action import ImageBulkAction
 
 
-class DeleteBulkAction(ImageBulkAction):
+class DeleteBulkAction(ReferenceIndexMixin, ImageBulkAction):
     display_name = _("Delete")
     action_type = "delete"
     aria_label = _("Delete selected images")
@@ -25,6 +26,9 @@ class DeleteBulkAction(ImageBulkAction):
         ).delete()
         return num_parent_objects, 0
 
+    def get_usage_url(self, item):
+        return item.usage_url + "?describe_on_delete=1"
+
     def get_success_message(self, num_parent_objects, num_child_objects):
         return ngettext(
             "%(num_parent_objects)d image has been deleted",

wagtail/images/views/bulk_actions/image_bulk_action.py

@@ -8,7 +8,9 @@ class ImageBulkAction(BulkAction):
     models = [get_image_model()]
 
     def get_all_objects_in_listing_query(self, parent_id):
-        listing_objects = self.model.objects.all()
+        listing_objects = self.permission_policy.instances_user_has_permission_for(
+            self.request.user, "change"
+        )
         if parent_id is not None:
             listing_objects = listing_objects.filter(collection_id=parent_id)