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

wagtail/documents/tests/test_admin_views.py

@@ -2,6 +2,7 @@ import json
 from unittest import mock
 
 from django.contrib.auth.models import Group, Permission
+from django.contrib.contenttypes.models import ContentType
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.test import TestCase, TransactionTestCase
 from django.test.utils import override_settings
@@ -12,7 +13,13 @@ from django.utils.http import urlencode
 from wagtail.admin.admin_url_finder import AdminURLFinder
 from wagtail.documents import get_document_model, models
 from wagtail.documents.tests.utils import get_test_document_file
-from wagtail.models import Collection, GroupCollectionPermission, Page, ReferenceIndex
+from wagtail.models import (
+    Collection,
+    GroupCollectionPermission,
+    Page,
+    ReferenceIndex,
+    UploadedFile,
+)
 from wagtail.test.testapp.models import (
     CustomDocument,
     CustomDocumentWithAuthor,
@@ -86,6 +93,9 @@ class TestDocumentIndexView(WagtailTestUtils, TestCase):
         response = self.get()
         self.assertNotContains(response, "<th>Collection</th>", html=True)
         self.assertNotContains(response, "<td>Root</td>", html=True)
+        soup = self.get_soup(response.content)
+        collection_select = soup.select_one('select[name="collection_id"]')
+        self.assertIsNone(collection_select)
 
     def test_index_with_collection(self):
         root_collection = Collection.get_first_root_node()
@@ -97,8 +107,18 @@ class TestDocumentIndexView(WagtailTestUtils, TestCase):
         response = self.get()
         self.assertContains(response, "<th>Collection</th>", html=True)
         self.assertContains(response, "<td>Root</td>", html=True)
+
+        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"],
         )
 
@@ -162,7 +182,7 @@ class TestDocumentIndexView(WagtailTestUtils, TestCase):
     def test_search_form_rendered(self):
         response = self.get()
         html = response.content.decode()
-        search_url = reverse("wagtaildocs:index")
+        search_url = reverse("wagtaildocs:index_results")
 
         # Search form in the header should be rendered.
         self.assertTagInHTML(
@@ -172,6 +192,101 @@ class TestDocumentIndexView(WagtailTestUtils, TestCase):
             allow_extra_attrs=True,
         )
 
+    def test_tags(self):
+        document_two_tags = models.Document.objects.create(
+            title="Test document with two tags"
+        )
+        document_two_tags.tags.add("one", "two")
+
+        response = self.get()
+        self.assertEqual(response.status_code, 200)
+
+        soup = self.get_soup(response.content)
+        current_tags = soup.select("input[name=tag][checked]")
+        self.assertFalse(current_tags)
+
+        tags = soup.select("#id_tag label")
+        self.assertCountEqual(
+            [tags.get_text(strip=True) for tags in tags],
+            ["one", "two"],
+        )
+
+    def test_tag_filtering(self):
+        models.Document.objects.create(title="Test document with no tags")
+
+        document_one_tag = models.Document.objects.create(
+            title="Test document with one tag"
+        )
+        document_one_tag.tags.add("one")
+
+        document_two_tags = models.Document.objects.create(
+            title="Test document with two tags"
+        )
+        document_two_tags.tags.add("one", "two")
+
+        document_unrelated_tag = models.Document.objects.create(
+            title="Test document with a different tag"
+        )
+        document_unrelated_tag.tags.add("unrelated")
+
+        # no filtering
+        response = self.get()
+        # four documents created above
+        self.assertEqual(response.context["page_obj"].paginator.count, 4)
+
+        # filter all documents with tag 'one'
+        response = self.get({"tag": "one"})
+        self.assertEqual(response.context["page_obj"].paginator.count, 2)
+
+        # filter all documents with tag 'two'
+        response = self.get({"tag": "two"})
+        self.assertEqual(response.context["page_obj"].paginator.count, 1)
+
+        # filter all documents 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):
+            document = models.Document.objects.create(title="Test document %i" % i)
+            if i % 2 != 0:
+                document.tags.add("even")
+                document.save()
+
+        response = self.get({"tag": "even", "p": 2})
+        self.assertEqual(response.status_code, 200)
+
+        response_body = response.content.decode("utf8")
+
+        # prev link should exist and include tag
+        self.assertTrue(
+            "?p=1&amp;tag=even" in response_body or "?tag=even&amp;p=1" in response_body
+        )
+        # next link should exist and include tag
+        self.assertTrue(
+            "?p=3&amp;tag=even" in response_body or "?tag=even&amp;p=3" in response_body
+        )
+
 
 class TestDocumentIndexViewSearch(WagtailTestUtils, TransactionTestCase):
     def setUp(self):
@@ -225,6 +340,24 @@ class TestDocumentIndexViewSearch(WagtailTestUtils, TransactionTestCase):
         self.assertTemplateUsed(response, "wagtaildocs/documents/index.html")
         self.assertContains(response, "There are 50 matches")
 
+    def test_tag_filtering_with_search_term(self):
+        models.Document.objects.create(title="Test document with no tags")
+
+        document_one_tag = models.Document.objects.create(
+            title="Test document with one tag"
+        )
+        document_one_tag.tags.add("one")
+
+        document_two_tags = models.Document.objects.create(
+            title="Test document with two tags"
+        )
+        document_two_tags.tags.add("one", "two")
+
+        # The tag shouldn't be ignored, so the result should be the documents
+        # 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, 2)
+
 
 class TestDocumentIndexResultsView(WagtailTestUtils, TransactionTestCase):
     def setUp(self):
@@ -1277,15 +1410,16 @@ class TestMultipleCustomDocumentUploaderWithRequiredField(TestMultipleDocumentUp
     def setUp(self):
         super().setUp()
 
-        # Create an UploadedDocument for running tests on
-        self.uploaded_document = models.UploadedDocument.objects.create(
+        # Create an UploadedFile for running tests on
+        self.uploaded_document = UploadedFile.objects.create(
+            for_content_type=ContentType.objects.get_for_model(get_document_model()),
             file=get_test_document_file(),
             uploaded_by_user=self.user,
         )
 
     def test_add_post(self):
         """
-        This tests that a POST request to the add view saves the document as an UploadedDocument
+        This tests that a POST request to the add view saves the document as an UploadedFile
         and returns an edit form
         """
         response = self.client.post(
@@ -1326,11 +1460,11 @@ class TestMultipleCustomDocumentUploaderWithRequiredField(TestMultipleDocumentUp
 
         # Check JSON
         response_json = json.loads(response.content.decode())
-        self.assertIn("uploaded_document_id", response_json)
+        self.assertIn("uploaded_file_id", response_json)
         self.assertIn("form", response_json)
         self.assertIn("success", response_json)
         self.assertEqual(
-            response_json["uploaded_document_id"],
+            response_json["uploaded_file_id"],
             response.context["uploaded_document"].id,
         )
         self.assertTrue(response_json["success"])
@@ -1363,10 +1497,10 @@ class TestMultipleCustomDocumentUploaderWithRequiredField(TestMultipleDocumentUp
 
         # Check JSON
         response_json = json.loads(response.content.decode())
-        self.assertIn("uploaded_document_id", response_json)
+        self.assertIn("uploaded_file_id", response_json)
         self.assertIn("form", response_json)
         self.assertEqual(
-            response_json["uploaded_document_id"],
+            response_json["uploaded_file_id"],
             response.context["uploaded_document"].id,
         )
         self.assertTrue(response_json["success"])
@@ -1419,11 +1553,11 @@ class TestMultipleCustomDocumentUploaderWithRequiredField(TestMultipleDocumentUp
 
         # Check JSON
         response_json = json.loads(response.content.decode())
-        self.assertIn("uploaded_document_id", response_json)
+        self.assertIn("uploaded_file_id", response_json)
         self.assertIn("form", response_json)
         self.assertIn("success", response_json)
         self.assertEqual(
-            response_json["uploaded_document_id"],
+            response_json["uploaded_file_id"],
             response.context["uploaded_document"].id,
         )
         self.assertTrue(response_json["success"])
@@ -1438,10 +1572,10 @@ class TestMultipleCustomDocumentUploaderWithRequiredField(TestMultipleDocumentUp
     def test_create_from_upload_invalid_post(self):
         """
         Posting an invalid form to the create_from_uploaded_document view throws a validation error
-        and leaves the UploadedDocument intact
+        and leaves the UploadedFile intact
         """
         doc_count_before = CustomDocumentWithAuthor.objects.count()
-        uploaded_doc_count_before = models.UploadedDocument.objects.count()
+        uploaded_doc_count_before = UploadedFile.objects.count()
 
         # Send request
         response = self.client.post(
@@ -1459,9 +1593,9 @@ class TestMultipleCustomDocumentUploaderWithRequiredField(TestMultipleDocumentUp
         )
 
         doc_count_after = CustomDocumentWithAuthor.objects.count()
-        uploaded_doc_count_after = models.UploadedDocument.objects.count()
+        uploaded_doc_count_after = UploadedFile.objects.count()
 
-        # no changes to document / UploadedDocument count
+        # no changes to document / UploadedFile count
         self.assertEqual(doc_count_after, doc_count_before)
         self.assertEqual(uploaded_doc_count_after, uploaded_doc_count_before)
 
@@ -1497,7 +1631,7 @@ class TestMultipleCustomDocumentUploaderWithRequiredField(TestMultipleDocumentUp
         Posting a valid form to the create_from_uploaded_document view will create the document
         """
         doc_count_before = CustomDocumentWithAuthor.objects.count()
-        uploaded_doc_count_before = models.UploadedDocument.objects.count()
+        uploaded_doc_count_before = UploadedFile.objects.count()
 
         # Send request
         response = self.client.post(
@@ -1519,7 +1653,7 @@ class TestMultipleCustomDocumentUploaderWithRequiredField(TestMultipleDocumentUp
         )
 
         doc_count_after = CustomDocumentWithAuthor.objects.count()
-        uploaded_doc_count_after = models.UploadedDocument.objects.count()
+        uploaded_doc_count_after = UploadedFile.objects.count()
 
         # Check response
         self.assertEqual(response.status_code, 200)
@@ -1530,7 +1664,7 @@ class TestMultipleCustomDocumentUploaderWithRequiredField(TestMultipleDocumentUp
         self.assertIn("doc_id", response_json)
         self.assertTrue(response_json["success"])
 
-        # Document should have been created, UploadedDocument deleted
+        # Document should have been created, UploadedFile deleted
         self.assertEqual(doc_count_after, doc_count_before + 1)
         self.assertEqual(uploaded_doc_count_after, uploaded_doc_count_before - 1)
 
@@ -1544,7 +1678,7 @@ class TestMultipleCustomDocumentUploaderWithRequiredField(TestMultipleDocumentUp
 
     def test_delete_uploaded_document(self):
         """
-        This tests that a POST request to the delete view deletes the UploadedDocument
+        This tests that a POST request to the delete view deletes the UploadedFile
         """
         # Send request
         response = self.client.post(
@@ -1559,9 +1693,7 @@ class TestMultipleCustomDocumentUploaderWithRequiredField(TestMultipleDocumentUp
 
         # Make sure the document is deleted
         self.assertFalse(
-            models.UploadedDocument.objects.filter(
-                id=self.uploaded_document.id
-            ).exists()
+            UploadedFile.objects.filter(id=self.uploaded_document.id).exists()
         )
 
         # Check JSON

wagtail/documents/tests/test_collection_privacy.py

@@ -1,6 +1,6 @@
 from django.contrib.auth.models import Group
 from django.core.files.base import ContentFile
-from django.test import TestCase
+from django.test import TestCase, override_settings
 from django.urls import reverse
 
 from wagtail.documents.models import Document
@@ -19,6 +19,7 @@ class TestCollectionPrivacyDocument(WagtailTestUtils, TestCase):
     def setUp(self):
         self.fake_file = ContentFile(b"A boring example document")
         self.fake_file.name = "test.txt"
+        self.collection = Collection.objects.get(id=2)
         self.password_collection = Collection.objects.get(name="Password protected")
         self.login_collection = Collection.objects.get(name="Login protected")
         self.group_collection = Collection.objects.get(name="Group protected")
@@ -106,6 +107,28 @@ class TestCollectionPrivacyDocument(WagtailTestUtils, TestCase):
             )
             self.assertRedirects(response, "/")
 
+    @override_settings(
+        WAGTAILDOCS_PASSWORD_REQUIRED_TEMPLATE="tests/custom_docs_password_required.html"
+    )
+    def test_anonymous_user_must_authenticate_with_custom_password_required_template(
+        self
+    ):
+        secret_document = Document.objects.create(
+            title="Test document",
+            file=self.fake_file,
+            collection=self.password_collection,
+        )
+        doc_url = reverse(
+            "wagtaildocs_serve", args=(secret_document.id, secret_document.filename)
+        )
+        response = self.client.get(doc_url)
+        self.assertNotEqual(
+            response.templates[0].name, "wagtaildocs/password_required.html"
+        )
+        self.assertEqual(
+            response.templates[0].name, "tests/custom_docs_password_required.html"
+        )
+
     def test_group_restriction_with_anonymous_user(self):
         response, url = self.get_document(self.group_collection)
         self.assertRedirects(response, f"/_util/login/?next={url}")
@@ -133,3 +156,34 @@ class TestCollectionPrivacyDocument(WagtailTestUtils, TestCase):
         self.login(username="eventmoderator", password="password")
         response, url = self.get_document(self.login_collection)
         self.assertEqual(response.status_code, 200)
+
+    def test_set_shared_password_with_logged_in_user(self):
+        self.login()
+        response = self.client.get(
+            reverse("wagtailadmin_collections:set_privacy", args=(self.collection.id,)),
+        )
+
+        input_el = self.get_soup(response.content).select_one("[data-field-input]")
+        self.assertEqual(response.status_code, 200)
+
+        # check that input option for password is visible
+        self.assertIn("password", response.context["form"].fields)
+
+        # check that the option for password is visible
+        self.assertIsNotNone(input_el)
+
+    @override_settings(
+        WAGTAILDOCS_PRIVATE_COLLECTION_OPTIONS={"SHARED_PASSWORD": False}
+    )
+    def test_unset_shared_password_with_logged_in_user(self):
+        self.login()
+        response = self.client.get(
+            reverse("wagtailadmin_collections:set_privacy", args=(self.collection.id,)),
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertNotIn("password", response.context["form"].fields)
+        self.assertFalse(
+            response.context["form"]
+            .fields["restriction_type"]
+            .valid_value(CollectionViewRestriction.PASSWORD)
+        )

wagtail/documents/tests/test_rich_text.py

@@ -1,4 +1,5 @@
 from django.test import TestCase
+from django.urls import reverse_lazy
 
 from wagtail.documents import get_document_model
 from wagtail.documents.rich_text import (
@@ -8,6 +9,7 @@ from wagtail.documents.rich_text.editor_html import (
     DocumentLinkHandler as EditorHtmlDocumentLinkHandler,
 )
 from wagtail.fields import RichTextField
+from wagtail.rich_text.feature_registry import FeatureRegistry
 from wagtail.test.utils import WagtailTestUtils
 
 
@@ -60,3 +62,15 @@ class TestFrontendDocumentLinkHandler(TestCase):
             ),
             [(get_document_model(), "1", "", "")],
         )
+
+
+class TestEntityFeatureChooserUrls(TestCase):
+    def test_chooser_urls_exist(self):
+        features = FeatureRegistry()
+        document = features.get_editor_plugin("draftail", "document-link")
+
+        self.assertIsNotNone(document.data.get("chooserUrls"))
+        self.assertEqual(
+            document.data["chooserUrls"]["documentChooser"],
+            reverse_lazy("wagtaildocs_chooser:choose"),
+        )

wagtail/documents/views/documents.py

@@ -12,6 +12,7 @@ from django.utils.translation import gettext_lazy, ngettext
 
 from wagtail.admin import messages
 from wagtail.admin.auth import PermissionPolicyChecker
+from wagtail.admin.filters import BaseMediaFilterSet
 from wagtail.admin.ui.tables import (
     BulkActionsCheckboxColumn,
     Column,
@@ -25,9 +26,9 @@ from wagtail.admin.views import generic
 from wagtail.documents import get_document_model
 from wagtail.documents.forms import get_document_form
 from wagtail.documents.permissions import permission_policy
-from wagtail.models import Collection
 
 permission_checker = PermissionPolicyChecker(permission_policy)
+Document = get_document_model()
 
 
 class BulkActionsColumn(BulkActionsCheckboxColumn):
@@ -49,6 +50,14 @@ class DocumentTable(Table):
         return context
 
 
+class DocumentsFilterSet(BaseMediaFilterSet):
+    permission_policy = permission_policy
+
+    class Meta:
+        model = Document
+        fields = []
+
+
 class IndexView(generic.IndexView):
     permission_policy = permission_policy
     any_permission_required = ["add", "change", "delete"]
@@ -65,9 +74,11 @@ class IndexView(generic.IndexView):
     results_template_name = "wagtaildocs/documents/index_results.html"
     default_ordering = "title"
     table_class = DocumentTable
+    filterset_class = DocumentsFilterSet
     model = get_document_model()
     add_item_label = gettext_lazy("Add a document")
     show_other_searches = True
+    _show_breadcrumbs = True
 
     def get_base_queryset(self):
         # Get documents (filtered by user permission)
@@ -75,17 +86,10 @@ class IndexView(generic.IndexView):
             self.request.user, ["change", "delete"]
         ).select_related("collection")
 
-    def filter_queryset(self, queryset):
-        self.current_collection = None
-        collection_id = self.request.GET.get("collection_id")
-        if collection_id:
-            try:
-                self.current_collection = Collection.objects.get(id=collection_id)
-                queryset = queryset.filter(collection=self.current_collection)
-            except (ValueError, Collection.DoesNotExist):
-                pass
-
-        return queryset
+    @cached_property
+    def current_collection(self):
+        # Upon validation, the cleaned data is a Collection instance
+        return self.filters and self.filters.form.cleaned_data.get("collection_id")
 
     @cached_property
     def columns(self):
@@ -106,7 +110,7 @@ class IndexView(generic.IndexView):
                 width="16%",
             ),
         ]
-        if self.collections:
+        if self.filters and "collection_id" in self.filters.filters:
             columns.insert(
                 3,
                 Column("collection", label=_("Collection"), accessor="collection.name"),
@@ -130,10 +134,10 @@ class IndexView(generic.IndexView):
         return next_url
 
     def get_add_url(self):
-        # Pass the query string so that the collection filter is preserved
+        # Pass the collection filter to prefill the add form's collection field
         return set_query_params(
             super().get_add_url(),
-            self.request.GET.copy(),
+            {"collection_id": self.current_collection and self.current_collection.pk},
         )
 
     def get_edit_url(self, instance):
@@ -142,15 +146,14 @@ class IndexView(generic.IndexView):
             {"next": self.get_next_url()},
         )
 
+    def get_filterset_kwargs(self):
+        kwargs = super().get_filterset_kwargs()
+        kwargs["is_searching"] = self.is_searching
+        return kwargs
+
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
-
-        context.update(
-            {
-                "collections": self.collections,
-                "current_collection": self.current_collection,
-            }
-        )
+        context["current_collection"] = self.current_collection
         return context
 
 

wagtail/documents/views/multiple.py

@@ -12,14 +12,12 @@ from wagtail.admin.views.generic.multiple_upload import EditView as BaseEditView
 
 from .. import get_document_model
 from ..forms import get_document_form, get_document_multi_form
-from ..models import UploadedDocument
 from ..permissions import permission_policy
 
 
 class AddView(BaseAddView):
     permission_policy = permission_policy
     template_name = "wagtaildocs/multiple/add.html"
-    upload_model = UploadedDocument
 
     edit_object_url_name = "wagtaildocs:edit_multiple"
     delete_object_url_name = "wagtaildocs:delete_multiple"
@@ -31,7 +29,7 @@ class AddView(BaseAddView):
     delete_upload_url_name = "wagtaildocs:delete_upload_multiple"
     edit_upload_form_prefix = "uploaded-document"
     context_upload_name = "uploaded_document"
-    context_upload_id_name = "uploaded_document_id"
+    context_upload_id_name = "uploaded_file_id"
 
     def get_model(self):
         return get_document_model()
@@ -90,8 +88,7 @@ class DeleteView(BaseDeleteView):
 class CreateFromUploadedDocumentView(BaseCreateFromUploadView):
     edit_upload_url_name = "wagtaildocs:create_multiple_from_uploaded_document"
     delete_upload_url_name = "wagtaildocs:delete_upload_multiple"
-    upload_model = UploadedDocument
-    upload_pk_url_kwarg = "uploaded_document_id"
+    upload_pk_url_kwarg = "uploaded_file_id"
     edit_upload_form_prefix = "uploaded-document"
     context_object_id_name = "doc_id"
     context_upload_name = "uploaded_document"
@@ -118,5 +115,7 @@ class CreateFromUploadedDocumentView(BaseCreateFromUploadView):
 
 
 class DeleteUploadView(BaseDeleteUploadView):
-    upload_model = UploadedDocument
-    upload_pk_url_kwarg = "uploaded_document_id"
+    upload_pk_url_kwarg = "uploaded_file_id"
+
+    def get_model(self):
+        return get_document_model()

wagtail/documents/views/serve.py

@@ -1,3 +1,5 @@
+from warnings import warn
+
 from django.conf import settings
 from django.http import FileResponse, Http404, HttpResponse
 from django.shortcuts import get_object_or_404, redirect
@@ -12,6 +14,7 @@ from wagtail.documents.models import document_served
 from wagtail.forms import PasswordViewRestrictionForm
 from wagtail.models import CollectionViewRestriction
 from wagtail.utils import sendfile_streaming_backend
+from wagtail.utils.deprecation import RemovedInWagtail70Warning
 from wagtail.utils.sendfile import sendfile
 
 
@@ -135,9 +138,21 @@ def authenticate_with_password(request, restriction_id):
 
     password_required_template = getattr(
         settings,
-        "DOCUMENT_PASSWORD_REQUIRED_TEMPLATE",
+        "WAGTAILDOCS_PASSWORD_REQUIRED_TEMPLATE",
         "wagtaildocs/password_required.html",
     )
 
+    if hasattr(settings, "DOCUMENT_PASSWORD_REQUIRED_TEMPLATE"):
+        warn(
+            "The `DOCUMENT_PASSWORD_REQUIRED_TEMPLATE` setting is deprecated - use `WAGTAILDOCS_PASSWORD_REQUIRED_TEMPLATE` instead.",
+            category=RemovedInWagtail70Warning,
+        )
+
+        password_required_template = getattr(
+            settings,
+            "DOCUMENT_PASSWORD_REQUIRED_TEMPLATE",
+            password_required_template,
+        )
+
     context = {"form": form, "action_url": action_url}
     return TemplateResponse(request, password_required_template, context)