from collections.abc import Mapping from datetime import date, datetime, timezone from functools import wraps from typing import Any, Optional from unittest import mock from django import forms from django.conf import settings from django.contrib.auth import get_user_model from django.contrib.auth.models import AnonymousUser, Permission from django.core import checks from django.core.exceptions import FieldDoesNotExist, ImproperlyConfigured from django.test import RequestFactory, TestCase, override_settings from django.urls import reverse from django.utils.html import escape, json_script from freezegun import freeze_time from wagtail.admin.forms import WagtailAdminModelForm, WagtailAdminPageForm from wagtail.admin.panels import ( CommentPanel, FieldPanel, FieldRowPanel, HelpPanel, InlinePanel, MultiFieldPanel, MultipleChooserPanel, ObjectList, PageChooserPanel, Panel, PublishingPanel, TabbedInterface, TitleFieldPanel, expand_panel_list, extract_panel_definitions_from_model_class, get_form_for_model, ) from wagtail.admin.rich_text import DraftailRichTextArea from wagtail.admin.widgets import ( AdminAutoHeightTextInput, AdminDateInput, AdminPageChooser, ) from wagtail.contrib.forms.models import FormSubmission from wagtail.contrib.forms.panels import FormSubmissionsPanel from wagtail.coreutils import get_dummy_request from wagtail.images import get_image_model from wagtail.models import Comment, CommentReply, Page, Site from wagtail.test.testapp.forms import ValidatedPageForm from wagtail.test.testapp.models import ( Advert, EventPage, EventPageChooserModel, EventPageSpeaker, FormPageWithRedirect, GalleryPage, PageChooserModel, PersonPage, RestaurantPage, RestaurantTag, SimplePage, ValidatedPage, ) from wagtail.test.utils import WagtailTestUtils class TestGetFormForModel(TestCase): def test_get_form_without_model(self): edit_handler = ObjectList() with self.assertRaisesMessage( AttributeError, "ObjectList is not bound to a model yet. " "Use `.bind_to_model(model)` before using this method.", ): edit_handler.get_form_class() def test_get_form_for_model_without_explicit_fields(self): # Failing to pass a 'fields' argument to get_form_for_model IS valid, and should result in # a form with no fields. EventPageForm = get_form_for_model( EventPage, form_class=WagtailAdminPageForm, ) self.assertTrue(issubclass(EventPageForm, WagtailAdminPageForm)) form = EventPageForm() self.assertNotIn("title", form.fields) self.assertNotIn("path", form.fields) def test_get_form_for_model_without_formsets(self): EventPageForm = get_form_for_model( EventPage, form_class=WagtailAdminPageForm, fields=["title", "slug", "date_from", "date_to"], ) form = EventPageForm() # form should be a subclass of WagtailAdminModelForm self.assertTrue(issubclass(EventPageForm, WagtailAdminModelForm)) # form should contain a title field (from the base Page) self.assertEqual(type(form.fields["title"]), forms.CharField) # and 'date_from' from EventPage self.assertEqual(type(form.fields["date_from"]), forms.DateField) # the widget should be overridden with AdminDateInput as per FORM_FIELD_OVERRIDES self.assertEqual(type(form.fields["date_from"].widget), AdminDateInput) # treebeard's 'path' field should be excluded self.assertNotIn("path", form.fields) def test_get_form_for_model_with_formsets(self): EventPageForm = get_form_for_model( EventPage, form_class=WagtailAdminPageForm, fields=["title", "slug", "date_from", "date_to"], formsets=["speakers", "related_links"], ) form = EventPageForm() # all child relations become formsets by default self.assertIn("speakers", form.formsets) self.assertIn("related_links", form.formsets) def test_direct_form_field_overrides(self): # Test that field overrides defined through DIRECT_FORM_FIELD_OVERRIDES # are applied SimplePageForm = get_form_for_model( SimplePage, form_class=WagtailAdminPageForm, fields=["title", "slug", "content"], ) self.assertTrue(issubclass(SimplePageForm, WagtailAdminPageForm)) simple_form = SimplePageForm() # plain TextFields should use AdminAutoHeightTextInput as the widget self.assertEqual( type(simple_form.fields["content"].widget), AdminAutoHeightTextInput ) # This override should NOT be applied to subclasses of TextField such as # RichTextField - they should retain their default widgets EventPageForm = get_form_for_model( EventPage, form_class=WagtailAdminPageForm, fields=["title", "slug", "body"] ) event_form = EventPageForm() self.assertEqual(type(event_form.fields["body"].widget), DraftailRichTextArea) def test_get_form_for_model_with_specific_fields(self): EventPageForm = get_form_for_model( EventPage, form_class=WagtailAdminPageForm, fields=["date_from"], formsets=["speakers"], ) form = EventPageForm() # form should contain date_from but not title self.assertEqual(type(form.fields["date_from"]), forms.DateField) self.assertEqual(type(form.fields["date_from"].widget), AdminDateInput) self.assertNotIn("title", form.fields) # formsets should include speakers but not related_links self.assertIn("speakers", form.formsets) self.assertNotIn("related_links", form.formsets) def test_get_form_for_model_without_explicit_formsets(self): # omitting the 'formsets' argument from get_form_for_model should return a form with no # formsets, rather than a form with ALL OF THE FORMSETS which somehow seemed like a good # idea once EventPageForm = get_form_for_model( EventPage, form_class=WagtailAdminPageForm, fields=["date_from"], ) form = EventPageForm() self.assertNotIn("speakers", form.formsets) self.assertNotIn("related_links", form.formsets) def test_get_form_for_model_with_excluded_fields(self): EventPageForm = get_form_for_model( EventPage, form_class=WagtailAdminPageForm, exclude=["title"], exclude_formsets=["related_links"], ) form = EventPageForm() # form should contain date_from but not title self.assertEqual(type(form.fields["date_from"]), forms.DateField) self.assertEqual(type(form.fields["date_from"].widget), AdminDateInput) self.assertNotIn("title", form.fields) # formsets should include speakers but not related_links self.assertIn("speakers", form.formsets) self.assertNotIn("related_links", form.formsets) def test_get_form_for_model_with_widget_overrides_by_class(self): EventPageForm = get_form_for_model( EventPage, form_class=WagtailAdminPageForm, fields=["date_to", "date_from"], widgets={"date_from": forms.PasswordInput}, ) form = EventPageForm() self.assertEqual(type(form.fields["date_from"]), forms.DateField) self.assertEqual(type(form.fields["date_from"].widget), forms.PasswordInput) def test_get_form_for_model_with_widget_overrides_by_instance(self): EventPageForm = get_form_for_model( EventPage, form_class=WagtailAdminPageForm, fields=["date_to", "date_from"], widgets={"date_from": forms.PasswordInput()}, ) form = EventPageForm() self.assertEqual(type(form.fields["date_from"]), forms.DateField) self.assertEqual(type(form.fields["date_from"].widget), forms.PasswordInput) def test_tag_widget_is_passed_tag_model(self): RestaurantPageForm = get_form_for_model( RestaurantPage, form_class=WagtailAdminPageForm, fields=["title", "slug", "tags"], ) form_html = RestaurantPageForm().as_p() self.assertIn( 'data-w-tag-url-value="/admin/tag-autocomplete/tests/restauranttag/"', form_html, ) # widget should pick up the free_tagging=False attribute on the tag model # and set itself to autocomplete only self.assertIn(escape('"autocompleteOnly": true'), form_html) # Free tagging should also be disabled at the form field validation level RestaurantTag.objects.create(name="Italian", slug="italian") RestaurantTag.objects.create(name="Indian", slug="indian") form = RestaurantPageForm( { "title": "Buonasera", "slug": "buonasera", "tags": "Italian, delicious", } ) self.assertTrue(form.is_valid()) self.assertEqual(form.cleaned_data["tags"], ["Italian"]) def clear_edit_handler(page_cls): def decorator(fn): @wraps(fn) def decorated(*args, **kwargs): # Clear any old panel definitions generated page_cls.get_edit_handler.cache_clear() try: fn(*args, **kwargs) finally: # Clear the bad panel definition generated just now page_cls.get_edit_handler.cache_clear() return decorated return decorator class TestPageEditHandlers(TestCase): @clear_edit_handler(EventPage) def test_get_edit_handler(self): """ Forms for pages should have a base class of WagtailAdminPageForm. """ edit_handler = EventPage.get_edit_handler() EventPageForm = edit_handler.get_form_class() # The generated form should inherit from WagtailAdminPageForm self.assertTrue(issubclass(EventPageForm, WagtailAdminPageForm)) @clear_edit_handler(ValidatedPage) def test_get_form_for_page_with_custom_base(self): """ ValidatedPage sets a custom base_form_class. This should be used as the base class when constructing a form for ValidatedPages """ edit_handler = ValidatedPage.get_edit_handler() GeneratedValidatedPageForm = edit_handler.get_form_class() # The generated form should inherit from ValidatedPageForm, because # ValidatedPage.base_form_class == ValidatedPageForm self.assertTrue(issubclass(GeneratedValidatedPageForm, ValidatedPageForm)) @clear_edit_handler(ValidatedPage) def test_check_invalid_base_form_class(self): class BadFormClass: pass invalid_base_form = checks.Error( "ValidatedPage.base_form_class does not extend WagtailAdminPageForm", hint="Ensure that wagtail.admin.tests.test_edit_handlers.BadFormClass extends WagtailAdminPageForm", obj=ValidatedPage, id="wagtailadmin.E001", ) invalid_edit_handler = checks.Error( "ValidatedPage.get_edit_handler().get_form_class() does not extend WagtailAdminPageForm", hint="Ensure that the panel definition for ValidatedPage creates a subclass of WagtailAdminPageForm", obj=ValidatedPage, id="wagtailadmin.E002", ) with mock.patch.object(ValidatedPage, "base_form_class", new=BadFormClass): errors = checks.run_checks() # Only look at errors (e.g. ignore warnings about CSS not being built) errors = [e for e in errors if e.level >= checks.ERROR] # Errors may appear out of order, so sort them by id errors.sort(key=lambda e: e.id) self.assertEqual(errors, [invalid_base_form, invalid_edit_handler]) @clear_edit_handler(ValidatedPage) def test_custom_edit_handler_form_class(self): """ Set a custom edit handler on a Page class, but dont customise ValidatedPage.base_form_class, or provide a custom form class for the edit handler. Check the generated form class is of the correct type. """ ValidatedPage.edit_handler = TabbedInterface() with mock.patch.object( ValidatedPage, "edit_handler", new=TabbedInterface(), create=True ): form_class = ValidatedPage.get_edit_handler().get_form_class() self.assertTrue(issubclass(form_class, WagtailAdminPageForm)) errors = ValidatedPage.check() self.assertEqual(errors, []) @clear_edit_handler(ValidatedPage) def test_repr(self): edit_handler = ValidatedPage.get_edit_handler() handler_repr = repr(edit_handler) self.assertIn( "model=", handler_repr, ) bound_handler = edit_handler.get_bound_panel( instance=None, request=None, form=None ) bound_handler_repr = repr(bound_handler) self.assertIn( "model=", bound_handler_repr, ) self.assertIn("instance=None", bound_handler_repr) self.assertIn("request=None", bound_handler_repr) self.assertIn("form=None", bound_handler_repr) class TestExtractPanelDefinitionsFromModelClass(TestCase): def test_can_extract_panel_property(self): # A class with a 'panels' property defined should return that list result = extract_panel_definitions_from_model_class(EventPageSpeaker) self.assertEqual(len(result), 5) self.assertTrue(any(isinstance(panel, MultiFieldPanel) for panel in result)) def test_exclude(self): panels = extract_panel_definitions_from_model_class(Site, exclude=["hostname"]) for panel in panels: self.assertNotEqual(panel.field_name, "hostname") def test_can_build_panel_list(self): # EventPage has no 'panels' definition, so one should be derived from the field list panels = extract_panel_definitions_from_model_class(EventPage) self.assertTrue( any( isinstance(panel, FieldPanel) and panel.field_name == "date_from" for panel in panels ) ) class TestPanelAttributes(WagtailTestUtils, TestCase): def setUp(self): self.request = RequestFactory().get("/") user = self.create_superuser(username="admin") self.request.user = user self.user = self.login() # a custom tabbed interface for EventPage self.event_page_tabbed_interface = TabbedInterface( [ ObjectList( [ HelpPanel( "Double-check event details before submit.", attrs={"data-panel-type": "help"}, ), FieldPanel("title", widget=forms.Textarea), FieldRowPanel( [ FieldPanel("date_from"), FieldPanel( "date_to", attrs={"data-panel-type": "field"} ), ], attrs={"data-panel-type": "field-row"}, ), ], heading="Event details", classname="shiny", attrs={"data-panel-type": "object-list"}, ), ObjectList( [ InlinePanel( "speakers", label="Speakers", attrs={"data-panel-type": "inline"}, ), ], heading="Speakers", ), ObjectList( [ MultiFieldPanel( [ HelpPanel( "Double-check cost details before submit.", attrs={"data-panel-type": "help-cost"}, ), FieldPanel("cost"), FieldRowPanel( [ FieldPanel("cost"), FieldPanel( "cost", attrs={ "data-panel-type": "nested-object_list-multi_field-field_row-field" }, ), ], attrs={ "data-panel-type": "nested-object_list-multi_field-field_row" }, ), ], attrs={"data-panel-type": "multi-field"}, ) ], heading="Secret", ), ], attrs={"data-panel-type": "tabs"}, ).bind_to_model(EventPage) def test_render(self): EventPageForm = self.event_page_tabbed_interface.get_form_class() event = EventPage(title="Abergavenny sheepdog trials") form = EventPageForm(instance=event) tabbed_interface = self.event_page_tabbed_interface.get_bound_panel( instance=event, form=form, request=self.request, ) result = tabbed_interface.render_html() # result should contain custom data attributes assigned to panels # each attribute should be rendered exactly once self.assertEqual(result.count('data-panel-type="tabs"'), 1) self.assertEqual(result.count('data-panel-type="multi-field"'), 1) self.assertEqual( result.count('data-panel-type="nested-object_list-multi_field-field_row"'), 1, ) self.assertEqual( result.count( 'data-panel-type="nested-object_list-multi_field-field_row-field"' ), 1, ) self.assertEqual(result.count('data-panel-type="help-cost"'), 1) self.assertEqual(result.count('data-panel-type="inline"'), 1) self.assertEqual(result.count('data-panel-type="object-list"'), 1) self.assertEqual(result.count('data-panel-type="field-row"'), 1) self.assertEqual(result.count('data-panel-type="field"'), 1) self.assertEqual(result.count('data-panel-type="help"'), 1) class TestTabbedInterface(WagtailTestUtils, TestCase): def setUp(self): self.request = RequestFactory().get("/") user = self.create_superuser(username="admin") self.request.user = user self.user = self.login() self.other_user = self.create_user(username="admin2", email="test2@email.com") p = Permission.objects.get(codename="custom_see_panel_setting") self.other_user.user_permissions.add(p) # a custom tabbed interface for EventPage self.event_page_tabbed_interface = TabbedInterface( [ ObjectList( [ FieldPanel("title", widget=forms.Textarea), FieldPanel("date_from"), FieldPanel("date_to"), ], heading="Event details", classname="shiny", ), ObjectList( [ InlinePanel("speakers", label="Speakers"), ], heading="Speakers", ), ObjectList( [ FieldPanel("cost", permission="superuser"), ], heading="Secret", ), ObjectList( [ FieldPanel("cost"), ], permission="tests.custom_see_panel_setting", heading="Custom Setting", ), ObjectList( [ FieldPanel("cost"), ], permission="tests.other_custom_see_panel_setting", heading="Other Custom Setting", ), ], attrs={"data-controller": "my-tabbed-interface"}, ).bind_to_model(EventPage) def test_get_form_class(self): EventPageForm = self.event_page_tabbed_interface.get_form_class() form = EventPageForm() # form must include the 'speakers' formset required by the speakers InlinePanel self.assertIn("speakers", form.formsets) # form must respect any overridden widgets self.assertEqual(type(form.fields["title"].widget), forms.Textarea) def test_render(self): EventPageForm = self.event_page_tabbed_interface.get_form_class() event = EventPage(title="Abergavenny sheepdog trials") form = EventPageForm(instance=event) tabbed_interface = self.event_page_tabbed_interface.get_bound_panel( instance=event, form=form, request=self.request, ) result = tabbed_interface.render_html() # result should contain tab buttons self.assertIn( '', result, ) self.assertIn( '', result, ) # result should contain tab panels self.assertIn('aria-labelledby="tab-label-event_details"', result) self.assertIn('aria-labelledby="tab-label-speakers"', result) # result should contain rendered content from descendants self.assertIn("Abergavenny sheepdog trials", result) # result should contain the data-controller attribute as defined by attrs self.assertIn('data-controller="my-tabbed-interface"', result) # this result should not include fields that are not covered by the panel definition self.assertNotIn("signup_link", result) def test_required_fields(self): # get_form_options should report the set of form fields to be rendered recursively by children of TabbedInterface result = set(self.event_page_tabbed_interface.get_form_options()["fields"]) self.assertEqual(result, {"title", "date_from", "date_to", "cost"}) def test_render_form_content(self): EventPageForm = self.event_page_tabbed_interface.get_form_class() event = EventPage(title="Abergavenny sheepdog trials") form = EventPageForm(instance=event) tabbed_interface = self.event_page_tabbed_interface.get_bound_panel( instance=event, form=form, request=self.request, ) result = tabbed_interface.render_form_content() # rendered output should contain field content as above self.assertIn("Abergavenny sheepdog trials", result) # rendered output should NOT include fields that are in the model but not represented # in the panel definition self.assertNotIn("signup_link", result) def test_tabs_permissions(self): """ test that three tabs show when the current user has permission to see all three test that two tabs show when the current user does not have permission to see all three """ EventPageForm = self.event_page_tabbed_interface.get_form_class() event = EventPage(title="Abergavenny sheepdog trials") form = EventPageForm(instance=event) with self.subTest("Super user test"): # when signed in as a superuser all tabs should be visible tabbed_interface = self.event_page_tabbed_interface.get_bound_panel( instance=event, form=form, request=self.request, ) result = tabbed_interface.render_html() self.assertIn( '', result, ) self.assertIn( '', result, ) self.assertIn( '', result, ) self.assertIn( '', result, ) self.assertNotIn( '', result, ) self.assertIn( '', result, ) self.assertNotIn( '', result) # result should contain the specified attrs self.assertIn('data-controller="my-object-list"', result) # result should contain labels for children self.assertIn( 'help text', result) self.assertIn( '
', result, ) self.assertIn("Choose a page", result) def test_render_error(self): form = self.PageChooserForm({"page": ""}, instance=self.test_instance) self.assertFalse(form.is_valid()) page_chooser_panel = self.my_page_chooser_panel.get_bound_panel( instance=self.test_instance, form=form, request=self.request ) self.assertIn("error-message", page_chooser_panel.render_html()) def test_override_page_type(self): # Model has a foreign key to Page, but we specify EventPage in the PageChooserPanel # to restrict the chooser to that page type my_page_object_list = ObjectList( [PageChooserPanel("page", "tests.EventPage")] ).bind_to_model(EventPageChooserModel) my_page_chooser_panel = my_page_object_list.children[0] PageChooserForm = my_page_object_list.get_form_class() form = PageChooserForm(instance=self.test_instance) page_chooser_panel = my_page_chooser_panel.get_bound_panel( instance=self.test_instance, form=form, request=self.request ) result = page_chooser_panel.render_html() expected_js = 'new PageChooser("{id}", {{"modelNames": ["{model}"], "canChooseRoot": false, "userPerms": null, "modalUrl": "/admin/choose-page/", "parentId": {parent}}});'.format( id="id_page", model="tests.eventpage", parent=self.events_index_page.id ) self.assertIn(expected_js, result) def test_autodetect_page_type(self): # Model has a foreign key to EventPage, which we want to autodetect # instead of specifying the page type in PageChooserPanel my_page_object_list = ObjectList([PageChooserPanel("page")]).bind_to_model( EventPageChooserModel, ) my_page_chooser_panel = my_page_object_list.children[0] PageChooserForm = my_page_object_list.get_form_class() form = PageChooserForm(instance=self.test_instance) page_chooser_panel = my_page_chooser_panel.get_bound_panel( instance=self.test_instance, form=form, request=self.request ) result = page_chooser_panel.render_html() expected_js = 'new PageChooser("{id}", {{"modelNames": ["{model}"], "canChooseRoot": false, "userPerms": null, "modalUrl": "/admin/choose-page/", "parentId": {parent}}});'.format( id="id_page", model="tests.eventpage", parent=self.events_index_page.id ) self.assertIn(expected_js, result) def test_target_models(self): panel = PageChooserPanel("page", "wagtailcore.site").bind_to_model( PageChooserModel ) widget = panel.get_form_options()["widgets"]["page"] self.assertEqual(widget.target_models, [Site]) def test_target_models_malformed_type(self): panel = PageChooserPanel("page", "snowman").bind_to_model(PageChooserModel) self.assertRaises(ImproperlyConfigured, panel.get_form_options) def test_target_models_nonexistent_type(self): panel = PageChooserPanel("page", "snowman.lorry").bind_to_model( PageChooserModel ) self.assertRaises(ImproperlyConfigured, panel.get_form_options) class TestInlinePanel(WagtailTestUtils, TestCase): fixtures = ["test.json"] def setUp(self): self.request = RequestFactory().get("/") user = AnonymousUser() # technically, Anonymous users cannot access the admin self.request.user = user def test_render(self): """ Check that the inline panel renders the panels set on the model when no 'panels' parameter is passed in the InlinePanel definition """ speaker_object_list = ObjectList( [ InlinePanel( "speakers", label="Speakers", classname="classname-for-speakers", attrs={"data-controller": "test"}, ) ] ).bind_to_model(EventPage) EventPageForm = speaker_object_list.get_form_class() # SpeakerInlinePanel should instruct the form class to include a 'speakers' formset self.assertEqual(["speakers"], list(EventPageForm.formsets.keys())) event_page = EventPage.objects.get(slug="christmas") form = EventPageForm(instance=event_page) panel = speaker_object_list.get_bound_panel( instance=event_page, form=form, request=self.request ) result = panel.render_html() # FIXME: reinstate when we pass classnames to the template again # self.assertIn('
  • ', result) self.assertIn( '