wagtail 7.2.1__py3-none-any.whl → 7.3rc1__py3-none-any.whl

wagtail/snippets/tests/test_locking.py

@@ -345,6 +345,34 @@ class TestEditLockedSnippet(BaseLockingTestCase):
         # Check that the snippet is not edited
         self.assertEqual(self.snippet.text, "I'm a lockable snippet!")
 
+    def test_edit_post_locked_with_json_response(self):
+        # Lock the snippet
+        self.lock_snippet(self.create_user("user2"))
+
+        # Try to edit the snippet
+        response = self.client.post(
+            self.get_url("edit"),
+            {"text": "Edited while locked"},
+            headers={"Accept": "application/json"},
+        )
+        self.refresh_snippet()
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(
+            response.json(),
+            {
+                "success": False,
+                "error_code": "locked",
+                "error_message": f"The {self.model_name} could not be saved as it is locked",
+            },
+        )
+
+        # Check that the snippet is still locked
+        self.assertTrue(self.snippet.locked)
+
+        # Check that the snippet is not edited
+        self.assertEqual(self.snippet.text, "I'm a lockable snippet!")
+
     def test_edit_post_locked_by_self(self):
         """A user can edit a snippet that is locked by themselves."""
         # Lock the snippet

wagtail/snippets/tests/test_permissions.py

@@ -0,0 +1,167 @@
+from django.contrib.admin.utils import quote
+from django.contrib.auth.models import Permission
+from django.test import TestCase
+from django.urls import reverse
+
+from wagtail.test.testapp.models import Advert
+from wagtail.test.utils import WagtailTestUtils
+
+
+class TestAddOnlyPermissions(WagtailTestUtils, TestCase):
+    fixtures = ["test.json"]
+
+    def setUp(self):
+        self.test_snippet = Advert.objects.get(pk=1)
+
+        # Create a user with add_advert permission but not change_advert
+        user = self.create_user(
+            username="addonly", email="addonly@example.com", password="password"
+        )
+        add_permission = Permission.objects.get(
+            content_type__app_label="tests", codename="add_advert"
+        )
+        admin_permission = Permission.objects.get(
+            content_type__app_label="wagtailadmin", codename="access_admin"
+        )
+        user.user_permissions.add(add_permission, admin_permission)
+        self.login(username="addonly", password="password")
+
+    def test_get_index(self):
+        response = self.client.get(reverse("wagtailsnippets_tests_advert:list"))
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "wagtailsnippets/snippets/index.html")
+
+        # user should get an "Add advert" button
+        self.assertContains(response, "Add advert")
+
+    def test_get_add(self):
+        response = self.client.get(reverse("wagtailsnippets_tests_advert:add"))
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "wagtailsnippets/snippets/create.html")
+        self.assertEqual(response.context["header_icon"], "snippet")
+
+    def test_get_edit(self):
+        response = self.client.get(
+            reverse(
+                "wagtailsnippets_tests_advert:edit",
+                args=[quote(self.test_snippet.pk)],
+            )
+        )
+        # permission should be denied
+        self.assertRedirects(response, reverse("wagtailadmin_home"))
+
+    def test_get_delete(self):
+        response = self.client.get(
+            reverse(
+                "wagtailsnippets_tests_advert:delete",
+                args=[quote(self.test_snippet.pk)],
+            )
+        )
+        # permission should be denied
+        self.assertRedirects(response, reverse("wagtailadmin_home"))
+
+
+class TestEditOnlyPermissions(WagtailTestUtils, TestCase):
+    fixtures = ["test.json"]
+
+    def setUp(self):
+        self.test_snippet = Advert.objects.get(pk=1)
+
+        # Create a user with change_advert permission but not add_advert
+        user = self.create_user(
+            username="changeonly", email="changeonly@example.com", password="password"
+        )
+        change_permission = Permission.objects.get(
+            content_type__app_label="tests", codename="change_advert"
+        )
+        admin_permission = Permission.objects.get(
+            content_type__app_label="wagtailadmin", codename="access_admin"
+        )
+        user.user_permissions.add(change_permission, admin_permission)
+        self.login(username="changeonly", password="password")
+
+    def test_get_index(self):
+        response = self.client.get(reverse("wagtailsnippets_tests_advert:list"))
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "wagtailsnippets/snippets/index.html")
+
+        # user should not get an "Add advert" button
+        self.assertNotContains(response, "Add advert")
+
+    def test_get_add(self):
+        response = self.client.get(reverse("wagtailsnippets_tests_advert:add"))
+        # permission should be denied
+        self.assertRedirects(response, reverse("wagtailadmin_home"))
+
+    def test_get_edit(self):
+        response = self.client.get(
+            reverse(
+                "wagtailsnippets_tests_advert:edit",
+                args=[quote(self.test_snippet.pk)],
+            )
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "wagtailsnippets/snippets/edit.html")
+        self.assertEqual(response.context["header_icon"], "snippet")
+
+    def test_get_delete(self):
+        response = self.client.get(
+            reverse(
+                "wagtailsnippets_tests_advert:delete",
+                args=[quote(self.test_snippet.pk)],
+            )
+        )
+        # permission should be denied
+        self.assertRedirects(response, reverse("wagtailadmin_home"))
+
+
+class TestDeleteOnlyPermissions(WagtailTestUtils, TestCase):
+    fixtures = ["test.json"]
+
+    def setUp(self):
+        self.test_snippet = Advert.objects.get(pk=1)
+
+        # Create a user with delete_advert permission
+        user = self.create_user(username="deleteonly", password="password")
+        change_permission = Permission.objects.get(
+            content_type__app_label="tests", codename="delete_advert"
+        )
+        admin_permission = Permission.objects.get(
+            content_type__app_label="wagtailadmin", codename="access_admin"
+        )
+        user.user_permissions.add(change_permission, admin_permission)
+        self.login(username="deleteonly", password="password")
+
+    def test_get_index(self):
+        response = self.client.get(reverse("wagtailsnippets_tests_advert:list"))
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "wagtailsnippets/snippets/index.html")
+
+        # user should not get an "Add advert" button
+        self.assertNotContains(response, "Add advert")
+
+    def test_get_add(self):
+        response = self.client.get(reverse("wagtailsnippets_tests_advert:add"))
+        # permission should be denied
+        self.assertRedirects(response, reverse("wagtailadmin_home"))
+
+    def test_get_edit(self):
+        response = self.client.get(
+            reverse(
+                "wagtailsnippets_tests_advert:edit",
+                args=[quote(self.test_snippet.pk)],
+            )
+        )
+        # permission should be denied
+        self.assertRedirects(response, reverse("wagtailadmin_home"))
+
+    def test_get_delete(self):
+        response = self.client.get(
+            reverse(
+                "wagtailsnippets_tests_advert:delete",
+                args=[quote(self.test_snippet.pk)],
+            )
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "wagtailadmin/generic/confirm_delete.html")
+        self.assertEqual(response.context["header_icon"], "snippet")

wagtail/snippets/tests/test_preview.py

@@ -480,7 +480,7 @@ class TestEnablePreview(WagtailTestUtils, TestCase):
     def test_show_preview_panel_on_edit_with_single_mode(self):
         edit_url = self.get_url(self.single, "edit", args=(self.single.pk,))
         preview_url = self.get_url(
-            self.single, "preview_on_edit", args=(self.multiple.pk,)
+            self.single, "preview_on_edit", args=(self.single.pk,)
         )
         new_tab_url = preview_url + "?mode="
         response = self.client.get(edit_url)
@@ -574,7 +574,7 @@ class TestEnablePreview(WagtailTestUtils, TestCase):
     def test_custom_auto_update_interval(self):
         edit_url = self.get_url(self.single, "edit", args=(self.single.pk,))
         preview_url = self.get_url(
-            self.single, "preview_on_edit", args=(self.multiple.pk,)
+            self.single, "preview_on_edit", args=(self.single.pk,)
         )
         response = self.client.get(edit_url)
 
@@ -603,7 +603,7 @@ class TestEnablePreview(WagtailTestUtils, TestCase):
     def test_disable_auto_update_using_zero_interval(self):
         edit_url = self.get_url(self.single, "edit", args=(self.single.pk,))
         preview_url = self.get_url(
-            self.single, "preview_on_edit", args=(self.multiple.pk,)
+            self.single, "preview_on_edit", args=(self.single.pk,)
         )
         response = self.client.get(edit_url)
 

wagtail/snippets/tests/test_revert_view.py

@@ -0,0 +1,343 @@
+from django.conf import settings
+from django.contrib.admin.utils import quote
+from django.contrib.auth.models import Permission
+from django.contrib.contenttypes.models import ContentType
+from django.test import TestCase
+from django.urls import reverse
+from django.utils.timezone import now
+from freezegun import freeze_time
+
+from wagtail.models import ModelLogEntry
+from wagtail.test.testapp.models import (
+    Advert,
+    DraftStateModel,
+    MultiPreviewModesModel,
+    RevisableModel,
+)
+from wagtail.test.utils import WagtailTestUtils
+
+
+class TestSnippetRevisions(WagtailTestUtils, TestCase):
+    @property
+    def revert_url(self):
+        return self.get_url(
+            "revisions_revert", args=[quote(self.snippet.pk), self.initial_revision.pk]
+        )
+
+    def get(self):
+        return self.client.get(self.revert_url)
+
+    def post(self, post_data=None):
+        return self.client.post(self.revert_url, post_data)
+
+    def get_url(self, url_name, args=None):
+        view_name = self.snippet.snippet_viewset.get_url_name(url_name)
+        if args is None:
+            args = [quote(self.snippet.pk)]
+        return reverse(view_name, args=args)
+
+    def setUp(self):
+        self.user = self.login()
+
+        with freeze_time("2022-05-10 11:00:00"):
+            self.snippet = RevisableModel.objects.create(text="The original text")
+            self.initial_revision = self.snippet.save_revision(user=self.user)
+            ModelLogEntry.objects.create(
+                content_type=ContentType.objects.get_for_model(RevisableModel),
+                label="The original text",
+                action="wagtail.create",
+                timestamp=now(),
+                object_id=self.snippet.pk,
+                revision=self.initial_revision,
+                content_changed=True,
+            )
+
+        self.snippet.text = "The edited text"
+        self.snippet.save()
+        self.edit_revision = self.snippet.save_revision(user=self.user, log_action=True)
+
+    def test_get_revert_revision(self):
+        response = self.get()
+        self.assertEqual(response.status_code, 200)
+
+        if settings.USE_TZ:
+            # the default timezone is "Asia/Tokyo", so we expect UTC +9
+            expected_date_string = "May 10, 2022, 8 p.m."
+        else:
+            expected_date_string = "May 10, 2022, 11 a.m."
+
+        # Message should be shown
+        self.assertContains(
+            response,
+            f"You are viewing a previous version of this Revisable model from <b>{expected_date_string}</b> by",
+            count=1,
+        )
+
+        # Form should show the content of the revision, not the current draft
+        soup = self.get_soup(response.content)
+        textarea = soup.select_one("textarea[name='text']")
+        self.assertIsNotNone(textarea)
+        self.assertEqual(textarea.text.strip(), "The original text")
+
+        # Form action url should point to the revisions_revert view
+        form_tag = f'<form action="{self.revert_url}" method="POST">'
+        html = response.content.decode()
+        self.assertTagInHTML(form_tag, html, count=1, allow_extra_attrs=True)
+
+        # Buttons should be relabelled
+        self.assertContains(response, "Replace current revision", count=1)
+
+        soup = self.get_soup(response.content)
+        form = soup.select_one("form[data-edit-form]")
+        self.assertIsNotNone(form)
+
+        # Autosave should be disabled
+        self.assertNotIn("w-autosave", form["data-controller"].split())
+        self.assertNotIn("w-autosave", form["data-action"])
+        self.assertIsNone(form.attrs.get("data-w-autosave-interval-value"))
+
+    def test_get_revert_revision_with_non_revisable_snippet(self):
+        snippet = Advert.objects.create(text="foo")
+        response = self.client.get(
+            f"/admin/snippets/tests/advert/history/{snippet.pk}/revisions/1/revert/"
+        )
+        self.assertEqual(response.status_code, 404)
+
+    def test_get_with_limited_permissions(self):
+        self.user.is_superuser = False
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                content_type__app_label="wagtailadmin", codename="access_admin"
+            )
+        )
+        self.user.save()
+
+        response = self.get()
+        self.assertEqual(response.status_code, 302)
+
+    def test_get_with_draft_state_snippet(self):
+        self.snippet = DraftStateModel.objects.create(text="Draft-enabled Foo")
+        self.initial_revision = self.snippet.save_revision()
+        response = self.get()
+
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "wagtailsnippets/snippets/edit.html")
+        soup = self.get_soup(response.content)
+
+        # The save button should be labelled "Replace current draft"
+        footer = soup.select_one("footer")
+        save_button = footer.select_one(
+            'button[type="submit"]:not([name="action-publish"])'
+        )
+        self.assertIsNotNone(save_button)
+        self.assertEqual(save_button.text.strip(), "Replace current draft")
+        # The publish button should exist and have name="action-publish"
+        publish_button = footer.select_one(
+            'button[type="submit"][name="action-publish"]'
+        )
+        self.assertIsNotNone(publish_button)
+        self.assertEqual(publish_button.text.strip(), "Publish this version")
+        self.assertEqual(
+            set(publish_button.get("class")),
+            {"button", "action-save", "button-longrunning"},
+        )
+
+        # Should not show the Unpublish action menu item
+        unpublish_url = reverse(
+            "wagtailsnippets_tests_draftstatemodel:unpublish",
+            args=(quote(self.snippet.pk),),
+        )
+        unpublish_button = footer.select_one(f'a[href="{unpublish_url}"]')
+        self.assertIsNone(unpublish_button)
+
+    def test_get_with_previewable_snippet(self):
+        self.snippet = MultiPreviewModesModel.objects.create(text="Preview-enabled foo")
+        self.initial_revision = self.snippet.save_revision()
+
+        self.snippet.text = "Preview-enabled bar"
+        self.snippet.save_revision()
+
+        response = self.get()
+
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "wagtailsnippets/snippets/edit.html")
+
+        # Message should be shown
+        self.assertContains(
+            response,
+            "You are viewing a previous version of this",
+            count=1,
+        )
+
+        # Form should show the content of the revision, not the current draft
+        self.assertContains(response, "Preview-enabled foo")
+
+        # Form action url should point to the revisions_revert view
+        form_tag = f'<form action="{self.revert_url}" method="POST">'
+        html = response.content.decode()
+        self.assertTagInHTML(form_tag, html, count=1, allow_extra_attrs=True)
+
+        # Buttons should be relabelled
+        self.assertContains(response, "Replace current revision", count=1)
+
+        # Should show the preview panel
+        preview_url = self.get_url("preview_on_edit")
+        self.assertContains(response, 'data-side-panel="preview"')
+        soup = self.get_soup(response.content)
+        controller = soup.select_one('[data-controller="w-preview"]')
+        self.assertIsNotNone(controller)
+        self.assertEqual(controller.get("data-w-preview-url-value"), preview_url)
+
+        # Should have the preview side panel toggle button
+        toggle_button = soup.find("button", {"data-side-panel-toggle": "preview"})
+        self.assertIsNotNone(toggle_button)
+        self.assertEqual("w-tooltip w-kbd", toggle_button["data-controller"])
+        self.assertEqual("mod+p", toggle_button["data-w-kbd-key-value"])
+
+    def test_replace_revision(self):
+        get_response = self.get()
+        text_from_revision = get_response.context["form"].initial["text"]
+
+        post_response = self.post(
+            post_data={
+                "text": text_from_revision + " reverted",
+                "revision": self.initial_revision.pk,
+            }
+        )
+        self.assertRedirects(post_response, self.get_url("list", args=[]))
+
+        self.snippet.refresh_from_db()
+        latest_revision = self.snippet.get_latest_revision()
+        log_entry = ModelLogEntry.objects.filter(revision=latest_revision).first()
+
+        # The instance should be updated
+        self.assertEqual(self.snippet.text, "The original text reverted")
+        # The initial revision, edited revision, and revert revision
+        self.assertEqual(self.snippet.revisions.count(), 3)
+        # The latest revision should be the revert revision
+        self.assertEqual(latest_revision.content["text"], "The original text reverted")
+
+        # A new log entry with "wagtail.revert" action should be created
+        self.assertIsNotNone(log_entry)
+        self.assertEqual(log_entry.action, "wagtail.revert")
+
+    def test_replace_with_limited_permissions(self):
+        self.user.is_superuser = False
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                content_type__app_label="wagtailadmin", codename="access_admin"
+            )
+        )
+        self.user.save()
+
+        response = self.post(
+            post_data={
+                "text": "test text",
+                "revision": self.initial_revision.pk,
+            }
+        )
+        self.assertEqual(response.status_code, 302)
+
+        self.snippet.refresh_from_db()
+        self.assertNotEqual(self.snippet.text, "test text")
+
+        # Only the initial revision and edited revision, no revert revision
+        self.assertEqual(self.snippet.revisions.count(), 2)
+
+    def test_replace_draft(self):
+        self.snippet = DraftStateModel.objects.create(
+            text="Draft-enabled Foo", live=False
+        )
+        self.initial_revision = self.snippet.save_revision()
+        self.snippet.text = "Draft-enabled Foo edited"
+        self.edit_revision = self.snippet.save_revision()
+        get_response = self.get()
+        text_from_revision = get_response.context["form"].initial["text"]
+
+        post_response = self.post(
+            post_data={
+                "text": text_from_revision + " reverted",
+                "revision": self.initial_revision.pk,
+            }
+        )
+        self.assertRedirects(post_response, self.get_url("edit"))
+
+        self.snippet.refresh_from_db()
+        latest_revision = self.snippet.get_latest_revision()
+        log_entry = ModelLogEntry.objects.filter(revision=latest_revision).first()
+        publish_log_entries = ModelLogEntry.objects.filter(
+            content_type=ContentType.objects.get_for_model(DraftStateModel),
+            action="wagtail.publish",
+            object_id=self.snippet.pk,
+        )
+
+        # The instance should be updated, since it is still a draft
+        self.assertEqual(self.snippet.text, "Draft-enabled Foo reverted")
+        # The initial revision, edited revision, and revert revision
+        self.assertEqual(self.snippet.revisions.count(), 3)
+        # The latest revision should be the revert revision
+        self.assertEqual(latest_revision.content["text"], "Draft-enabled Foo reverted")
+
+        # A new log entry with "wagtail.revert" action should be created
+        self.assertIsNotNone(log_entry)
+        self.assertEqual(log_entry.action, "wagtail.revert")
+
+        # There should be no log entries for the publish action
+        self.assertEqual(publish_log_entries.count(), 0)
+
+        # The instance should still be a draft
+        self.assertFalse(self.snippet.live)
+        self.assertTrue(self.snippet.has_unpublished_changes)
+        self.assertIsNone(self.snippet.first_published_at)
+        self.assertIsNone(self.snippet.last_published_at)
+        self.assertIsNone(self.snippet.live_revision)
+
+    def test_replace_publish(self):
+        self.snippet = DraftStateModel.objects.create(text="Draft-enabled Foo")
+        self.initial_revision = self.snippet.save_revision()
+        self.snippet.text = "Draft-enabled Foo edited"
+        self.edit_revision = self.snippet.save_revision()
+        get_response = self.get()
+        text_from_revision = get_response.context["form"].initial["text"]
+
+        timestamp = now()
+        with freeze_time(timestamp):
+            post_response = self.post(
+                post_data={
+                    "text": text_from_revision + " reverted",
+                    "revision": self.initial_revision.pk,
+                    "action-publish": "action-publish",
+                }
+            )
+
+        self.assertRedirects(post_response, self.get_url("list", args=[]))
+
+        self.snippet.refresh_from_db()
+        latest_revision = self.snippet.get_latest_revision()
+        log_entry = ModelLogEntry.objects.filter(revision=latest_revision).first()
+        revert_log_entries = ModelLogEntry.objects.filter(
+            content_type=ContentType.objects.get_for_model(DraftStateModel),
+            action="wagtail.revert",
+            object_id=self.snippet.pk,
+        )
+
+        # The instance should be updated
+        self.assertEqual(self.snippet.text, "Draft-enabled Foo reverted")
+        # The initial revision, edited revision, and revert revision
+        self.assertEqual(self.snippet.revisions.count(), 3)
+        # The latest revision should be the revert revision
+        self.assertEqual(latest_revision.content["text"], "Draft-enabled Foo reverted")
+
+        # The latest log entry should use the "wagtail.publish" action
+        self.assertIsNotNone(log_entry)
+        self.assertEqual(log_entry.action, "wagtail.publish")
+
+        # There should be a log entry for the revert action
+        self.assertEqual(revert_log_entries.count(), 1)
+
+        # The instance should be live
+        self.assertTrue(self.snippet.live)
+        self.assertFalse(self.snippet.has_unpublished_changes)
+        self.assertEqual(self.snippet.first_published_at, timestamp)
+        self.assertEqual(self.snippet.last_published_at, timestamp)
+        self.assertEqual(self.snippet.live_revision, self.snippet.latest_revision)

wagtail/snippets/tests/test_snippet_models.py

@@ -0,0 +1,112 @@
+from django.core import checks
+from django.test import TestCase
+from django.urls import reverse
+
+from wagtail.admin.forms import WagtailAdminModelForm
+from wagtail.admin.panels import FieldPanel, get_edit_handler
+from wagtail.snippets.models import SNIPPET_MODELS, register_snippet
+from wagtail.test.snippets.forms import FancySnippetForm
+from wagtail.test.snippets.models import (
+    AlphaSnippet,
+    FancySnippet,
+    RegisterDecorator,
+    RegisterFunction,
+    StandardSnippet,
+    ZuluSnippet,
+)
+from wagtail.test.testapp.models import AdvertWithTabbedInterface
+from wagtail.test.utils import WagtailTestUtils
+
+
+class TestModelOrdering(WagtailTestUtils, TestCase):
+    def setUp(self):
+        for i in range(1, 10):
+            AdvertWithTabbedInterface.objects.create(text="advert %d" % i)
+        AdvertWithTabbedInterface.objects.create(text="aaaadvert")
+        self.login()
+
+    def test_listing_respects_model_ordering(self):
+        response = self.client.get(
+            reverse("wagtailsnippets_tests_advertwithtabbedinterface:list")
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.context["page_obj"][0].text, "aaaadvert")
+
+    def test_chooser_respects_model_ordering(self):
+        response = self.client.get(
+            reverse("wagtailsnippetchoosers_tests_advertwithtabbedinterface:choose")
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.context["results"][0].text, "aaaadvert")
+
+
+class TestSnippetRegistering(TestCase):
+    def test_register_function(self):
+        self.assertIn(RegisterFunction, SNIPPET_MODELS)
+
+    def test_register_decorator(self):
+        # Misbehaving decorators often return None
+        self.assertIsNotNone(RegisterDecorator)
+        self.assertIn(RegisterDecorator, SNIPPET_MODELS)
+
+
+class TestSnippetOrdering(TestCase):
+    def setUp(self):
+        register_snippet(ZuluSnippet)
+        register_snippet(AlphaSnippet)
+
+    def test_snippets_ordering(self):
+        # Ensure AlphaSnippet is before ZuluSnippet
+        # Cannot check first and last position as other snippets
+        # may get registered elsewhere during test
+        self.assertLess(
+            SNIPPET_MODELS.index(AlphaSnippet), SNIPPET_MODELS.index(ZuluSnippet)
+        )
+
+
+class TestSnippetEditHandlers(WagtailTestUtils, TestCase):
+    def test_standard_edit_handler(self):
+        edit_handler = get_edit_handler(StandardSnippet)
+        form_class = edit_handler.get_form_class()
+        self.assertTrue(issubclass(form_class, WagtailAdminModelForm))
+        self.assertFalse(issubclass(form_class, FancySnippetForm))
+
+    def test_fancy_edit_handler(self):
+        edit_handler = get_edit_handler(FancySnippet)
+        form_class = edit_handler.get_form_class()
+        self.assertTrue(issubclass(form_class, WagtailAdminModelForm))
+        self.assertTrue(issubclass(form_class, FancySnippetForm))
+
+
+class TestPanelConfigurationChecks(WagtailTestUtils, TestCase):
+    def setUp(self):
+        self.warning_id = "wagtailadmin.W002"
+
+        def get_checks_result():
+            # run checks only with the 'panels' tag
+            checks_result = checks.run_checks(tags=["panels"])
+            return [
+                warning for warning in checks_result if warning.id == self.warning_id
+            ]
+
+        self.get_checks_result = get_checks_result
+
+    def test_model_with_single_tabbed_panel_only(self):
+        StandardSnippet.content_panels = [FieldPanel("text")]
+
+        warning = checks.Warning(
+            "StandardSnippet.content_panels will have no effect on snippets editing",
+            hint="""Ensure that StandardSnippet uses `panels` instead of `content_panels` \
+or set up an `edit_handler` if you want a tabbed editing interface.
+There are no default tabs on non-Page models so there will be no\
+ Content tab for the content_panels to render in.""",
+            obj=StandardSnippet,
+            id="wagtailadmin.W002",
+        )
+
+        checks_results = self.get_checks_result()
+
+        self.assertEqual([warning], checks_results)
+
+        # clean up for future checks
+        delattr(StandardSnippet, "content_panels")