wagtail 6.0.2__py3-none-any.whl → 6.1rc1__py3-none-any.whl

wagtail/images/tests/test_admin_views.py

@@ -4,6 +4,7 @@ import urllib
 
 from django.conf import settings
 from django.contrib.auth.models import Group, Permission
+from django.contrib.contenttypes.models import ContentType
 from django.core.files.uploadedfile import SimpleUploadedFile, TemporaryUploadedFile
 from django.template.defaultfilters import filesizeformat
 from django.template.loader import render_to_string
@@ -16,12 +17,12 @@ from django.utils.safestring import mark_safe
 
 from wagtail.admin.admin_url_finder import AdminURLFinder
 from wagtail.images import get_image_model
-from wagtail.images.models import UploadedImage
 from wagtail.images.utils import generate_signature
 from wagtail.models import (
     Collection,
     GroupCollectionPermission,
     Page,
+    UploadedFile,
     get_root_collection_id,
 )
 from wagtail.test.testapp.models import (
@@ -31,6 +32,7 @@ from wagtail.test.testapp.models import (
     VariousOnDeleteModel,
 )
 from wagtail.test.utils import WagtailTestUtils
+from wagtail.test.utils.timestamps import local_datetime
 
 from .utils import Image, get_test_image_file, get_test_image_file_svg
 
@@ -44,12 +46,10 @@ class TestImageIndexView(WagtailTestUtils, TestCase):
         self.kitten_image = Image.objects.create(
             title="a cute kitten",
             file=get_test_image_file(size=(1, 1)),
-            created_at=datetime.datetime(2020, 1, 1),
         )
         self.puppy_image = Image.objects.create(
             title="a cute puppy",
             file=get_test_image_file(size=(1, 1)),
-            created_at=datetime.datetime(2022, 2, 2),
         )
 
     def get(self, params={}):
@@ -85,12 +85,6 @@ class TestImageIndexView(WagtailTestUtils, TestCase):
         response = self.get({"p": 9999})
         self.assertEqual(response.status_code, 404)
 
-    def test_per_page(self):
-        response = self.get({"entries_per_page": 60})
-        self.assertContains(
-            response, '<option value="60" selected="selected">60</option>', html=True
-        )
-
     def test_pagination_preserves_other_params(self):
         root_collection = Collection.get_first_root_node()
         evil_plans_collection = root_collection.add_child(name="Evil plans")
@@ -151,41 +145,40 @@ class TestImageIndexView(WagtailTestUtils, TestCase):
         self.assertEqual(context["page_obj"].object_list[0], self.puppy_image)
         self.assertEqual(context["page_obj"].object_list[1], self.kitten_image)
 
+    @override_settings(WAGTAILIMAGES_INDEX_PAGE_SIZE=15)
     def test_default_entries_per_page(self):
-        for i in range(1, 33):
-            self.image = Image.objects.create(
+        images = [
+            Image(
                 title="Test image %i" % i,
                 file=get_test_image_file(size=(1, 1)),
             )
+            for i in range(1, 33)
+        ]
+        Image.objects.bulk_create(images)
 
         response = self.get()
         self.assertEqual(response.status_code, 200)
 
         object_list = response.context["page_obj"].object_list
-        # The default number of images shown is 30
-        self.assertEqual(len(object_list), 30)
-
-        response = self.get({"entries_per_page": 10})
-        self.assertEqual(response.status_code, 200)
-
-        object_list = response.context["page_obj"].object_list
-        self.assertEqual(len(object_list), 10)
+        # The number of images shown is 15
+        self.assertEqual(len(object_list), 15)
 
     def test_default_entries_per_page_uses_default(self):
-        for i in range(1, 33):
-            self.image = Image.objects.create(
+        images = [
+            Image(
                 title="Test image %i" % i,
                 file=get_test_image_file(size=(1, 1)),
             )
+            for i in range(1, 33)
+        ]
+        Image.objects.bulk_create(images)
 
         default_num_entries_per_page = 30
-        invalid_num_entries_values = [66, "a"]
-        for value in invalid_num_entries_values:
-            response = self.get({"entries_per_page": value})
-            self.assertEqual(response.status_code, 200)
+        response = self.get()
+        self.assertEqual(response.status_code, 200)
 
-            object_list = response.context["page_obj"].object_list
-            self.assertEqual(len(object_list), default_num_entries_per_page)
+        object_list = response.context["page_obj"].object_list
+        self.assertEqual(len(object_list), default_num_entries_per_page)
 
     def test_collection_order(self):
         root_collection = Collection.get_first_root_node()
@@ -193,8 +186,16 @@ class TestImageIndexView(WagtailTestUtils, TestCase):
         root_collection.add_child(name="Good plans")
 
         response = self.get()
+        soup = self.get_soup(response.content)
+        collection_options = soup.select(
+            'select[name="collection_id"] option[value]:not(option[value=""])'
+        )
+
         self.assertEqual(
-            [collection.name for collection in response.context["collections"]],
+            [
+                collection.get_text(strip=True).lstrip("↳ ")
+                for collection in collection_options
+            ],
             ["Root", "Evil plans", "Good plans"],
         )
 
@@ -234,13 +235,14 @@ class TestImageIndexView(WagtailTestUtils, TestCase):
         response = self.get()
         self.assertEqual(response.status_code, 200)
 
-        current_tag = response.context["current_tag"]
-        self.assertIsNone(current_tag)
+        soup = self.get_soup(response.content)
+        current_tags = soup.select("input[name=tag][checked]")
+        self.assertFalse(current_tags)
 
-        tags = response.context["popular_tags"]
-        self.assertTrue(
-            [tag.name for tag in tags] == ["one", "two"]
-            or [tag.name for tag in tags] == ["two", "one"]
+        tags = soup.select("#id_tag label")
+        self.assertCountEqual(
+            [tags.get_text(strip=True) for tags in tags],
+            ["one", "two"],
         )
 
     def test_tag_filtering(self):
@@ -261,10 +263,16 @@ class TestImageIndexView(WagtailTestUtils, TestCase):
         )
         image_two_tags.tags.add("one", "two")
 
+        image_unrelated_tag = Image.objects.create(
+            title="Test image with a different tag",
+            file=get_test_image_file(),
+        )
+        image_unrelated_tag.tags.add("unrelated")
+
         # no filtering
         response = self.get()
-        # three images created above plus the two untagged ones created in setUp()
-        self.assertEqual(response.context["page_obj"].paginator.count, 5)
+        # four images created above plus the two untagged ones created in setUp()
+        self.assertEqual(response.context["page_obj"].paginator.count, 6)
 
         # filter all images with tag 'one'
         response = self.get({"tag": "one"})
@@ -274,6 +282,30 @@ class TestImageIndexView(WagtailTestUtils, TestCase):
         response = self.get({"tag": "two"})
         self.assertEqual(response.context["page_obj"].paginator.count, 1)
 
+        # filter all images with tag 'one' or 'unrelated'
+        response = self.get({"tag": ["one", "unrelated"]})
+        self.assertEqual(response.context["page_obj"].paginator.count, 3)
+
+        soup = self.get_soup(response.content)
+
+        # Should check the 'one' and 'unrelated' tags checkboxes
+        tags = soup.select("#id_tag label")
+        self.assertCountEqual(
+            [
+                tag.get_text(strip=True)
+                for tag in tags
+                if tag.select_one("input[checked]") is not None
+            ],
+            ["one", "unrelated"],
+        )
+
+        # Should render the active filter pills separately for each tag
+        active_filters = soup.select('[data-w-active-filter-id="id_tag"]')
+        self.assertCountEqual(
+            [filter.get_text(separator=" ", strip=True) for filter in active_filters],
+            ["Tag: one", "Tag: unrelated"],
+        )
+
     def test_tag_filtering_preserves_other_params(self):
         for i in range(1, 130):
             image = Image.objects.create(
@@ -301,7 +333,7 @@ class TestImageIndexView(WagtailTestUtils, TestCase):
     def test_search_form_rendered(self):
         response = self.get()
         html = response.content.decode()
-        search_url = reverse("wagtailimages:index")
+        search_url = reverse("wagtailimages:index_results")
 
         # Search form in the header should be rendered.
         self.assertTagInHTML(
@@ -348,13 +380,17 @@ class TestImageIndexViewSearch(WagtailTestUtils, TransactionTestCase):
         self.kitten_image = Image.objects.create(
             title="a cute kitten",
             file=get_test_image_file(size=(1, 1)),
-            created_at=datetime.datetime(2020, 1, 1),
         )
         self.puppy_image = Image.objects.create(
             title="a cute puppy",
             file=get_test_image_file(size=(1, 1)),
-            created_at=datetime.datetime(2022, 2, 2),
         )
+        # The created_at field uses auto_now_add, so changing it needs to be
+        # done after the image is created.
+        self.kitten_image.created_at = local_datetime(2020, 1, 1)
+        self.kitten_image.save()
+        self.puppy_image.created_at = local_datetime(2022, 2, 2)
+        self.puppy_image.save()
 
     def get(self, params={}):
         return self.client.get(reverse("wagtailimages:index"), params)
@@ -405,9 +441,29 @@ class TestImageIndexViewSearch(WagtailTestUtils, TransactionTestCase):
         url = reverse("wagtailimages:add_multiple")
         self.assertContains(
             response,
-            f'<a href="{url}?q=Baker&amp;collection_id={child_collection[0].pk}"',
+            f'<a href="{url}?collection_id={child_collection[0].pk}"',
         )
 
+    def test_search_and_order_by_created_at(self):
+        old_image = Image.objects.create(
+            title="decades old cute tortoise",
+            file=get_test_image_file(size=(1, 1)),
+        )
+        old_image.created_at = local_datetime(2000, 1, 1)
+        old_image.save()
+        response = self.get({"q": "cute", "ordering": "created_at"})
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.context["query_string"], "cute")
+        self.assertEqual(
+            list(response.context["page_obj"].object_list),
+            [old_image, self.kitten_image, self.puppy_image],
+        )
+        soup = self.get_soup(response.content)
+        option = soup.select_one('select[name="ordering"] option[selected]')
+        self.assertIsNotNone(option)
+        self.assertEqual(option["value"], "created_at")
+        self.assertEqual(option.get_text(strip=True), "Oldest")
+
     def test_tag_filtering_with_search_term(self):
         Image.objects.create(
             title="Test image with no tags",
@@ -426,10 +482,10 @@ class TestImageIndexViewSearch(WagtailTestUtils, TransactionTestCase):
         )
         image_two_tags.tags.add("one", "two")
 
-        # The tag gets ignored, if a valid search term is present, so this will find all
-        # images, as all of them contain "test" in their titles.
+        # The tag shouldn't be ignored, so the result should be the images
+        # that have the "one" tag and "test" in the title.
         response = self.get({"tag": "one", "q": "test"})
-        self.assertEqual(response.context["page_obj"].paginator.count, 3)
+        self.assertEqual(response.context["page_obj"].paginator.count, 2)
 
 
 class TestImageListingResultsView(WagtailTestUtils, TransactionTestCase):
@@ -2886,7 +2942,7 @@ class TestMultipleImageUploaderWithCustomImageModel(WagtailTestUtils, TestCase):
 
     def test_unique_together_validation_error(self):
         """
-        If unique_together validation fails, create an UploadedImage and return a form so the
+        If unique_together validation fails, create an UploadedFile and return a form so the
         user can fix it
         """
         root_collection = Collection.get_first_root_node()
@@ -2895,7 +2951,7 @@ class TestMultipleImageUploaderWithCustomImageModel(WagtailTestUtils, TestCase):
         self.image.save()
 
         image_count_before = CustomImage.objects.count()
-        uploaded_image_count_before = UploadedImage.objects.count()
+        uploaded_image_count_before = UploadedFile.objects.count()
 
         response = self.client.post(
             reverse("wagtailimages:add_multiple"),
@@ -2908,9 +2964,9 @@ class TestMultipleImageUploaderWithCustomImageModel(WagtailTestUtils, TestCase):
         )
 
         image_count_after = CustomImage.objects.count()
-        uploaded_image_count_after = UploadedImage.objects.count()
+        uploaded_image_count_after = UploadedFile.objects.count()
 
-        # an UploadedImage should have been created now, but not a CustomImage
+        # an UploadedFile should have been created now, but not a CustomImage
         self.assertEqual(image_count_after, image_count_before)
         self.assertEqual(uploaded_image_count_after, uploaded_image_count_before + 1)
 
@@ -3034,8 +3090,9 @@ class TestMultipleImageUploaderWithCustomRequiredFields(WagtailTestUtils, TestCa
     def setUp(self):
         self.user = self.login()
 
-        # Create an UploadedImage for running tests on
-        self.uploaded_image = UploadedImage.objects.create(
+        # Create an UploadedFile for running tests on
+        self.uploaded_image = UploadedFile.objects.create(
+            for_content_type=ContentType.objects.get_for_model(get_image_model()),
             file=get_test_image_file(),
             uploaded_by_user=self.user,
         )
@@ -3053,11 +3110,11 @@ class TestMultipleImageUploaderWithCustomRequiredFields(WagtailTestUtils, TestCa
 
     def test_add_post(self):
         """
-        A POST request to the add view should create an UploadedImage rather than an image,
+        A POST request to the add view should create an UploadedFile rather than an image,
         as we do not have enough data to pass CustomImageWithAuthor's validation yet
         """
         image_count_before = CustomImageWithAuthor.objects.count()
-        uploaded_image_count_before = UploadedImage.objects.count()
+        uploaded_image_count_before = UploadedFile.objects.count()
 
         response = self.client.post(
             reverse("wagtailimages:add_multiple"),
@@ -3069,9 +3126,9 @@ class TestMultipleImageUploaderWithCustomRequiredFields(WagtailTestUtils, TestCa
         )
 
         image_count_after = CustomImageWithAuthor.objects.count()
-        uploaded_image_count_after = UploadedImage.objects.count()
+        uploaded_image_count_after = UploadedFile.objects.count()
 
-        # an UploadedImage should have been created now, but not a CustomImageWithAuthor
+        # an UploadedFile should have been created now, but not a CustomImageWithAuthor
         self.assertEqual(image_count_after, image_count_before)
         self.assertEqual(uploaded_image_count_after, uploaded_image_count_before + 1)
 
@@ -3137,10 +3194,10 @@ class TestMultipleImageUploaderWithCustomRequiredFields(WagtailTestUtils, TestCa
     def test_create_from_upload_invalid_post(self):
         """
         Posting an invalid form to the create_from_uploaded_image view throws a validation error and leaves the
-        UploadedImage intact
+        UploadedFile intact
         """
         image_count_before = CustomImageWithAuthor.objects.count()
-        uploaded_image_count_before = UploadedImage.objects.count()
+        uploaded_image_count_before = UploadedFile.objects.count()
 
         # Send request
         response = self.client.post(
@@ -3156,9 +3213,9 @@ class TestMultipleImageUploaderWithCustomRequiredFields(WagtailTestUtils, TestCa
         )
 
         image_count_after = CustomImageWithAuthor.objects.count()
-        uploaded_image_count_after = UploadedImage.objects.count()
+        uploaded_image_count_after = UploadedFile.objects.count()
 
-        # no changes to image / UploadedImage count
+        # no changes to image / UploadedFile count
         self.assertEqual(image_count_after, image_count_before)
         self.assertEqual(uploaded_image_count_after, uploaded_image_count_before)
 
@@ -3194,7 +3251,7 @@ class TestMultipleImageUploaderWithCustomRequiredFields(WagtailTestUtils, TestCa
         Posting a valid form to the create_from_uploaded_image view will create the image
         """
         image_count_before = CustomImageWithAuthor.objects.count()
-        uploaded_image_count_before = UploadedImage.objects.count()
+        uploaded_image_count_before = UploadedFile.objects.count()
 
         # Send request
         response = self.client.post(
@@ -3212,7 +3269,7 @@ class TestMultipleImageUploaderWithCustomRequiredFields(WagtailTestUtils, TestCa
         )
 
         image_count_after = CustomImageWithAuthor.objects.count()
-        uploaded_image_count_after = UploadedImage.objects.count()
+        uploaded_image_count_after = UploadedFile.objects.count()
 
         # Check response
         self.assertEqual(response.status_code, 200)
@@ -3223,7 +3280,7 @@ class TestMultipleImageUploaderWithCustomRequiredFields(WagtailTestUtils, TestCa
         self.assertIn("image_id", response_json)
         self.assertTrue(response_json["success"])
 
-        # Image should have been created, UploadedImage deleted
+        # Image should have been created, UploadedFile deleted
         self.assertEqual(image_count_after, image_count_before + 1)
         self.assertEqual(uploaded_image_count_after, uploaded_image_count_before - 1)
 
@@ -3239,7 +3296,7 @@ class TestMultipleImageUploaderWithCustomRequiredFields(WagtailTestUtils, TestCa
 
     def test_delete_uploaded_image(self):
         """
-        This tests that a POST request to the delete view deletes the UploadedImage
+        This tests that a POST request to the delete view deletes the UploadedFile
         """
         # Send request
         response = self.client.post(
@@ -3254,7 +3311,7 @@ class TestMultipleImageUploaderWithCustomRequiredFields(WagtailTestUtils, TestCa
 
         # Make sure the image is deleted
         self.assertFalse(
-            UploadedImage.objects.filter(id=self.uploaded_image.id).exists()
+            UploadedFile.objects.filter(id=self.uploaded_image.id).exists()
         )
 
         # Check JSON

wagtail/images/tests/test_image_operations.py

@@ -683,6 +683,16 @@ class TestFormatFilter(TestCase):
 
         self.assertEqual(out.format_name, "webp")
 
+    def test_ico(self):
+        fil = Filter(spec="width-400|format-ico")
+        image = Image.objects.create(
+            title="Test image",
+            file=get_test_image_file(),
+        )
+        out = fil.run(image, BytesIO())
+
+        self.assertEqual(out.format_name, "ico")
+
     def test_webp_lossless(self):
         fil = Filter(spec="width-400|format-webp-lossless")
         image = Image.objects.create(

wagtail/images/tests/test_models.py

@@ -4,7 +4,7 @@ from django.conf import settings
 from django.contrib.auth.models import Group, Permission
 from django.core.cache import caches
 from django.core.files import File
-from django.core.files.storage import DefaultStorage, Storage
+from django.core.files.storage import Storage, default_storage, storages
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.db.models import Prefetch
 from django.db.utils import IntegrityError
@@ -38,8 +38,7 @@ from .utils import (
 
 
 class CustomStorage(Storage):
-    def __init__(self):
-        super().__init__()
+    pass
 
 
 class TestImage(TestCase):
@@ -668,7 +667,7 @@ class TestRenditions(TestCase):
         self._test_get_renditions_performance(1)
 
         # ATTEMPT 3
-        # If the existing renditions are prefetched, no futher queries should
+        # If the existing renditions are prefetched, no further queries should
         # be needed, whether that's with prefetch_related("renditions") or
         # prefetch_renditions()
         self._test_get_renditions_performance(0, prefetch_all=True)
@@ -856,39 +855,42 @@ class TestRenditions(TestCase):
             rendition.background_position_style, "background-position: 50% 50%;"
         )
 
-    def test_custom_rendition_backend_setting(self):
-        """
-        Test the usage of WAGTAILIMAGES_RENDITION_STORAGE setting.
-        """
-        # when setting is not set, instance.get_storage() returns DefaultStorage
-        from django.conf import settings
-
-        bkp = settings
-
+    @override_settings()
+    def test_rendition_storage_setting_absent(self):
+        del settings.WAGTAILIMAGES_RENDITION_STORAGE
         self.assertFalse(hasattr(settings, "WAGTAILIMAGES_RENDITION_STORAGE"))
-        rendition1 = self.image.get_rendition("min-120x120")
-        self.assertIsInstance(rendition1.image.file.storage, DefaultStorage)
-
-        # when setting is set to a path
-        setattr(
-            settings,
-            "WAGTAILIMAGES_RENDITION_STORAGE",
-            "wagtail.images.tests.test_models.CustomStorage",
-        )
-        backend = get_rendition_storage()
-        self.assertIsInstance(backend, CustomStorage)
+        self.assertEqual(get_rendition_storage(), default_storage)
 
-        # when setting is set directly, get_rendition_storage() returns the custom storage backend
-        class CustomStorage2(Storage):
-            def __init__(self):
-                super().__init__()
+    @override_settings(
+        WAGTAILIMAGES_RENDITION_STORAGE="wagtail.images.tests.test_models.CustomStorage"
+    )
+    def test_rendition_storage_setting_given_dotted_path(self):
+        self.assertIsInstance(get_rendition_storage(), CustomStorage)
 
-        setattr(settings, "WAGTAILIMAGES_RENDITION_STORAGE", CustomStorage2())
-        backend = get_rendition_storage()
-        self.assertIsInstance(backend, CustomStorage2)
+    @override_settings(WAGTAILIMAGES_RENDITION_STORAGE=CustomStorage())
+    def test_rendition_storage_setting_given_storage_instance(self):
+        self.assertEqual(
+            get_rendition_storage(), settings.WAGTAILIMAGES_RENDITION_STORAGE
+        )
 
-        # clean up
-        settings = bkp
+    @override_settings(
+        STORAGES={
+            "default": {
+                "BACKEND": "django.core.files.storage.FileSystemStorage",
+            },
+            "staticfiles": {
+                "BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage",
+            },
+            "custom_storage": {
+                "BACKEND": "wagtail.images.tests.test_models.CustomStorage",
+            },
+        },
+        WAGTAILIMAGES_RENDITION_STORAGE="custom_storage",
+    )
+    def test_rendition_storage_setting_given_storage_alias(self):
+        self.assertEqual(
+            get_rendition_storage(), storages[settings.WAGTAILIMAGES_RENDITION_STORAGE]
+        )
 
 
 @override_settings(

wagtail/images/tests/test_rich_text.py

@@ -1,10 +1,12 @@
 from django.test import TestCase
+from django.urls import reverse_lazy
 
 from wagtail.fields import RichTextField
 from wagtail.images.rich_text import ImageEmbedHandler as FrontendImageEmbedHandler
 from wagtail.images.rich_text.editor_html import (
     ImageEmbedHandler as EditorHtmlImageEmbedHandler,
 )
+from wagtail.rich_text.feature_registry import FeatureRegistry
 from wagtail.test.utils import WagtailTestUtils
 
 from .utils import Image, get_test_image_file
@@ -140,3 +142,15 @@ class TestExtractReferencesWithImage(WagtailTestUtils, TestCase):
             ),
             [(Image, "52", "", "")],
         )
+
+
+class TestEntityFeatureChooserUrls(TestCase):
+    def test_chooser_urls_exist(self):
+        features = FeatureRegistry()
+        image = features.get_editor_plugin("draftail", "image")
+
+        self.assertIsNotNone(image.data.get("chooserUrls"))
+        self.assertEqual(
+            image.data["chooserUrls"]["imageChooser"],
+            reverse_lazy("wagtailimages_chooser:choose"),
+        )

wagtail/images/tests/utils.py

@@ -73,7 +73,7 @@ def get_test_image_file_svg(
 
 
 def get_test_bad_image():
-    # Create an image with a missing file, by deserializing fom a python object
+    # Create an image with a missing file, by deserializing from a python object
     # (which bypasses FileField's attempt to read the file)
     return list(
         serializers.deserialize(