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

wagtail/admin/tests/pages/test_edit_page.py

@@ -7,13 +7,13 @@ from django.conf import settings
 from django.contrib.auth.models import Group, Permission
 from django.core import mail
 from django.core.files.base import ContentFile
-from django.http import HttpRequest, HttpResponse
+from django.http import HttpRequest, HttpResponse, JsonResponse
 from django.test import TestCase, modify_settings, override_settings
 from django.urls import reverse
 from django.utils import timezone
 from django.utils.translation import gettext_lazy as _
 
-from wagtail.admin.action_menu import ActionMenuItem
+from wagtail.admin.action_menu import ActionMenuItem, PublishMenuItem
 from wagtail.admin.admin_url_finder import AdminURLFinder
 from wagtail.exceptions import PageClassNotFoundError
 from wagtail.models import (
@@ -119,6 +119,28 @@ class TestPageEdit(WagtailTestUtils, TestCase):
         # Login
         self.user = self.login()
 
+    def get_publish_button_label(self, response):
+        soup = self.get_soup(response.content)
+        publish_button = soup.select_one('.w-dropdown-button > [name="action-publish"]')
+        if publish_button is None:
+            publish_button = soup.select_one('[name="action-publish"]')
+        self.assertIsNotNone(publish_button)
+        label = publish_button.select_one('[data-w-progress-target="label"]')
+        self.assertIsNotNone(label)
+        return label.get_text(strip=True)
+
+    def schedule_child_page(self, go_live_at):
+        edit_url = reverse("wagtailadmin_pages:edit", args=(self.child_page.id,))
+        post_data = {
+            "title": self.child_page.title,
+            "content": self.child_page.content,
+            "slug": self.child_page.slug,
+            "go_live_at": submittable_timestamp(go_live_at),
+        }
+        self.client.post(edit_url, post_data, follow=True)
+        self.child_page.refresh_from_db(fields=["go_live_at"])
+        return edit_url
+
     def assertSchedulingDialogRendered(self, response, edit_url):
         # Should show the "Edit schedule" button
         html = response.content.decode()
@@ -220,6 +242,106 @@ class TestPageEdit(WagtailTestUtils, TestCase):
         expected_url = "/admin/pages/%d/edit/" % self.event_page.id
         self.assertEqual(url_finder.get_edit_url(self.event_page), expected_url)
 
+        # Autosave defaults to enabled with 500ms interval
+        soup = self.get_soup(response.content)
+        form = soup.select_one("form[data-edit-form]")
+        self.assertIsNotNone(form)
+        self.assertIn("w-autosave", form["data-controller"].split())
+        self.assertTrue(
+            {
+                "w-unsaved:add->w-autosave#save:prevent",
+                "w-autosave:success->w-unsaved#clear",
+            }.issubset(form["data-action"].split())
+        )
+        self.assertEqual(form.attrs.get("data-w-autosave-interval-value"), "500")
+
+    def test_loaded_revision_id_and_timestamp_included_in_form(self):
+        # Ensure there's a revision for the page
+        self.event_page.title = "Updated event page"
+        revision = self.event_page.save_revision()
+        self.assertEqual(self.event_page.revisions.count(), 1)
+
+        response = self.client.get(
+            reverse("wagtailadmin_pages:edit", args=(self.event_page.id,)),
+        )
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        form = soup.select_one("form[data-edit-form]")
+        self.assertIsNotNone(form)
+        loaded_revision = form.select_one("input[name='loaded_revision_id']")
+        self.assertIsNotNone(loaded_revision)
+        self.assertEqual(int(loaded_revision["value"]), revision.pk)
+        loaded_timestamp = form.select_one("input[name='loaded_revision_created_at']")
+        self.assertIsNotNone(loaded_timestamp)
+        self.assertEqual(loaded_timestamp["value"], revision.created_at.isoformat())
+
+    @override_settings(WAGTAIL_AUTOSAVE_INTERVAL=0)
+    def test_autosave_disabled(self):
+        response = self.client.get(
+            reverse("wagtailadmin_pages:edit", args=(self.event_page.id,))
+        )
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        form = soup.select_one("form[data-edit-form]")
+        self.assertIsNotNone(form)
+        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"))
+
+    @override_settings(WAGTAIL_AUTOSAVE_INTERVAL=2000)
+    def test_autosave_custom_interval(self):
+        response = self.client.get(
+            reverse("wagtailadmin_pages:edit", args=(self.event_page.id,))
+        )
+        self.assertEqual(response.status_code, 200)
+        soup = self.get_soup(response.content)
+        form = soup.select_one("form[data-edit-form]")
+        self.assertIsNotNone(form)
+        self.assertIn("w-autosave", form["data-controller"].split())
+        self.assertTrue(
+            {
+                "w-unsaved:add->w-autosave#save:prevent",
+                "w-autosave:success->w-unsaved#clear",
+            }.issubset(form["data-action"].split())
+        )
+        self.assertEqual(form.attrs.get("data-w-autosave-interval-value"), "2000")
+
+    def test_publish_button_shows_schedule_label_for_future_go_live(self):
+        go_live_at = timezone.now() + datetime.timedelta(hours=1)
+
+        response = self.client.get(self.schedule_child_page(go_live_at))
+        self.assertEqual(response.status_code, 200)
+
+        publish_menu_item = next(
+            item
+            for item in response.context["action_menu"].menu_items
+            if getattr(item, "name", "") == "action-publish"
+        )
+        publish_context = publish_menu_item.get_context_data(
+            response.context["action_menu"].context
+        )
+
+        self.assertTrue(publish_context["is_scheduled"])
+        self.assertEqual(self.get_publish_button_label(response), "Schedule to publish")
+
+    def test_publish_button_shows_publish_label_for_past_schedule(self):
+        go_live_at = timezone.now() - datetime.timedelta(hours=1)
+
+        response = self.client.get(self.schedule_child_page(go_live_at))
+        self.assertEqual(response.status_code, 200)
+
+        publish_menu_item = next(
+            item
+            for item in response.context["action_menu"].menu_items
+            if getattr(item, "name", "") == "action-publish"
+        )
+        publish_context = publish_menu_item.get_context_data(
+            response.context["action_menu"].context
+        )
+
+        self.assertFalse(publish_context["is_scheduled"])
+        self.assertEqual(self.get_publish_button_label(response), "Publish")
+
     def test_construct_page_action_menu_hook_with_custom_default_button(self):
         class CustomDefaultItem(ActionMenuItem):
             label = "Custom button"
@@ -468,6 +590,485 @@ class TestPageEdit(WagtailTestUtils, TestCase):
         # The draft_title should have a new title
         self.assertEqual(child_page_new.draft_title, post_data["title"])
 
+    def test_page_edit_post_with_json_response(self):
+        self.assertEqual(self.child_page.revisions.count(), 1)
+        loaded_revision = self.child_page.get_latest_revision()
+        # Tests simple editing
+        post_data = {
+            "title": "I've been edited!",
+            "content": "Some content",
+            "slug": "hello-world",
+            "loaded_revision_id": loaded_revision.pk,
+            "loaded_revision_created_at": loaded_revision.created_at.isoformat(),
+        }
+        response = self.client.post(
+            reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)),
+            post_data,
+            headers={"Accept": "application/json"},
+        )
+
+        # Should be a 200 OK JSON response
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response["Content-Type"], "application/json")
+        response_json = response.json()
+        self.assertEqual(response_json["success"], True)
+        self.assertEqual(response_json["pk"], self.child_page.pk)
+        self.assertEqual(response_json["field_updates"], {})
+
+        # Should create a new revision to be overwritten later
+        self.assertEqual(self.child_page.revisions.count(), 2)
+        self.assertNotEqual(response_json["revision_id"], loaded_revision.pk)
+        revision = self.child_page.revisions.get(pk=response_json["revision_id"])
+        self.assertEqual(
+            response_json["revision_created_at"],
+            revision.created_at.isoformat(),
+        )
+        self.assertEqual(revision.content["title"], "I've been edited!")
+        self.assertEqual(
+            response_json["comments"],
+            {
+                "comments": [],
+                "user": str(self.user.pk),
+                "authors": {},
+            },
+        )
+
+        soup = self.get_soup(response_json["html"])
+
+        # Should reload only the status side panel
+        side_panels = soup.select(
+            "template[data-controller='w-teleport']"
+            "[data-w-teleport-target-value^='[data-side-panel=']"
+            "[data-w-teleport-mode-value='innerHTML']"
+        )
+        self.assertEqual(len(side_panels), 1)
+        status_side_panel = side_panels[0]
+        self.assertEqual(
+            status_side_panel["data-w-teleport-target-value"],
+            "[data-side-panel='status']",
+        )
+
+        # These dialogs will be teleported to the body, so don't rerender them
+        # as we would end up with multiple instances of each
+        workflow_status_dialog = soup.find("div", id="workflow-status-dialog")
+        self.assertIsNone(workflow_status_dialog)
+        set_privacy_dialog = soup.find("div", id="set-privacy")
+        self.assertIsNone(set_privacy_dialog)
+
+        breadcrumbs = soup.find(
+            "template",
+            {
+                "data-controller": "w-teleport",
+                "data-w-teleport-target-value": "header [data-w-breadcrumbs]",
+                "data-w-teleport-mode-value": "outerHTML",
+            },
+        )
+        self.assertIsNotNone(breadcrumbs)
+        # Should not include header buttons as they're already rendered
+        self.assertIsNone(breadcrumbs.select_one("#w-slim-header-buttons"))
+
+        # History link should not be included as it's already present on the page
+        history_link = soup.find(
+            "template",
+            {
+                "data-controller": "w-teleport",
+                "data-w-teleport-target-value": "[data-side-panel-toggle]:last-of-type",
+                "data-w-teleport-mode-value": "afterend",
+            },
+        )
+        self.assertIsNone(history_link)
+
+        form_title_heading = soup.find(
+            "template",
+            {
+                "data-controller": "w-teleport",
+                "data-w-teleport-target-value": "#header-title span",
+                "data-w-teleport-mode-value": "textContent",
+            },
+        )
+        self.assertIsNone(form_title_heading)
+        header_title = soup.find(
+            "template",
+            {
+                "data-controller": "w-teleport",
+                "data-w-teleport-target-value": "head title",
+                "data-w-teleport-mode-value": "textContent",
+            },
+        )
+        self.assertIsNotNone(header_title)
+        self.assertEqual(
+            header_title.text.strip(),
+            # Looks a bit off because get_admin_display_title for SimplePage
+            # adds (simple page) suffix
+            "Editing Simple page: I've been edited! (simple page)",
+        )
+
+        # No form updates as we already have the loaded revision id and timestamp
+        form_adds = soup.find(
+            "template",
+            {
+                "data-controller": "w-teleport",
+                "data-w-teleport-target-value": "form[data-edit-form]",
+                "data-w-teleport-mode-value": "afterbegin",
+            },
+        )
+        self.assertIsNone(form_adds)
+
+        # Should not load the editing sessions module as it's already rendered
+        editing_sessions = soup.find(
+            "template",
+            {
+                "data-controller": "w-teleport",
+                "data-w-teleport-target-value": "#w-autosave-indicator",
+                "data-w-teleport-mode-value": "afterend",
+            },
+        )
+        self.assertIsNone(editing_sessions)
+
+        # The page should have "has_unpublished_changes" flag set
+        child_page_new = SimplePage.objects.get(id=self.child_page.id)
+        self.assertTrue(child_page_new.has_unpublished_changes)
+
+        # Page fields should not be changed (because we just created a new draft)
+        self.assertEqual(child_page_new.title, self.child_page.title)
+        self.assertEqual(child_page_new.content, self.child_page.content)
+        self.assertEqual(child_page_new.slug, self.child_page.slug)
+
+        # The draft_title should have a new title
+        self.assertEqual(child_page_new.draft_title, post_data["title"])
+
+    def test_save_outdated_revision_with_json_response(self):
+        self.assertEqual(self.child_page.revisions.count(), 1)
+        loaded_revision = self.child_page.get_latest_revision()
+        self.child_page.title = "Someone else edited after the page is loaded"
+        other_revision = self.child_page.save_revision(user=self.user)
+        self.assertEqual(self.child_page.revisions.count(), 2)
+
+        post_data = {
+            "title": "Just another edit submitted after the other edit is done",
+            "content": "Some content",
+            "slug": "hello-world",
+            "loaded_revision_id": loaded_revision.pk,
+        }
+        response = self.client.post(
+            reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)),
+            post_data,
+            headers={"Accept": "application/json"},
+        )
+
+        # Instead of creating a new revision for autosave (which means the user
+        # would unknowingly replace a newer revision), we return an error
+        # response that should be a 400 response
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response["Content-Type"], "application/json")
+        self.assertEqual(
+            response.json(),
+            {
+                "success": False,
+                "error_code": "invalid_revision",
+                "error_message": "Saving will overwrite a newer version.",
+            },
+        )
+
+        # Page fields should still be from the published version
+        self.child_page.refresh_from_db()
+        self.assertEqual(self.child_page.title, "Hello world!")
+
+        # The initially loaded revision, and the actual latest revision,
+        # should both be unchanged
+        self.assertEqual(self.child_page.revisions.count(), 2)
+        loaded_revision.refresh_from_db()
+        self.assertEqual(loaded_revision.content["title"], "Hello world!")
+        other_revision.refresh_from_db()
+        self.assertEqual(
+            other_revision.content["title"],
+            "Someone else edited after the page is loaded",
+        )
+        self.assertEqual(self.child_page.get_latest_revision().id, other_revision.id)
+
+    def test_save_outdated_revision_timestamp_with_json_response(self):
+        self.assertEqual(self.child_page.revisions.count(), 1)
+        loaded_revision = self.child_page.get_latest_revision()
+        loaded_revision_created_at = loaded_revision.created_at.isoformat()
+        # Simulate the loaded revision being updated via another session's autosave,
+        # which means the revision is overwritten with new content and created_at
+        self.child_page.title = "Someone else edited after the page is loaded"
+        self.child_page.save_revision(overwrite_revision=loaded_revision)
+        self.assertEqual(self.child_page.revisions.count(), 1)
+
+        post_data = {
+            "title": "Just another edit submitted after the other edit is done",
+            "content": "Some content",
+            "slug": "hello-world",
+            "loaded_revision_id": loaded_revision.pk,
+            "loaded_revision_created_at": loaded_revision_created_at,
+        }
+        response = self.client.post(
+            reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)),
+            post_data,
+            headers={"Accept": "application/json"},
+        )
+
+        # Instead of creating a new revision for autosave (which means the user
+        # would unknowingly replace the updated revision), we return an error
+        # response that should be a 400 response
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response["Content-Type"], "application/json")
+        self.assertEqual(
+            response.json(),
+            {
+                "success": False,
+                "error_code": "invalid_revision",
+                "error_message": "Saving will overwrite a newer version.",
+            },
+        )
+
+        # Page fields should still be from the published version
+        self.child_page.refresh_from_db()
+        self.assertEqual(self.child_page.title, "Hello world!")
+
+        # The initially loaded revision should prefer the other session's autosave
+        self.assertEqual(self.child_page.revisions.count(), 1)
+        loaded_revision.refresh_from_db()
+        self.assertEqual(
+            loaded_revision.content["title"],
+            "Someone else edited after the page is loaded",
+        )
+        self.assertEqual(self.child_page.get_latest_revision().id, loaded_revision.id)
+
+    def test_page_edit_post_with_overwrite_revision_and_json_response(self):
+        self.assertEqual(self.child_page.revisions.count(), 1)
+        loaded_revision = self.child_page.get_latest_revision()
+        self.child_page.title = "A changed title"
+        revision = self.child_page.save_revision(user=self.user)
+        self.assertEqual(self.child_page.revisions.count(), 2)
+
+        post_data = {
+            "title": "I've been edited again!",
+            "content": "Some content",
+            "slug": "hello-world",
+            # The page was originally loaded with loaded_revision, but
+            # a successful autosave created a new revision which we now
+            # want to overwrite with a new autosave request
+            "loaded_revision_id": loaded_revision.pk,
+            "overwrite_revision_id": revision.id,
+        }
+        response = self.client.post(
+            reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)),
+            post_data,
+            headers={"Accept": "application/json"},
+        )
+
+        # Should be a 200 OK JSON response
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response["Content-Type"], "application/json")
+        revision.refresh_from_db()
+        response_json = response.json()
+        self.assertEqual(response_json["success"], True)
+        self.assertEqual(response_json["pk"], self.child_page.pk)
+        self.assertEqual(response_json["revision_id"], revision.pk)
+        self.assertEqual(
+            response_json["revision_created_at"],
+            revision.created_at.isoformat(),
+        )
+
+        # The page should have "has_unpublished_changes" flag set
+        child_page_new = SimplePage.objects.get(id=self.child_page.id)
+        self.assertTrue(child_page_new.has_unpublished_changes)
+
+        # Page fields should still be from the published version
+        self.assertEqual(child_page_new.title, "Hello world!")
+
+        # The draft_title should have a new title
+        self.assertEqual(child_page_new.draft_title, "I've been edited again!")
+
+        # There should still be only two revisions, but the latest one should be overwritten
+        self.assertEqual(self.child_page.revisions.count(), 2)
+        self.assertEqual(self.child_page.get_latest_revision().id, revision.id)
+        revision.refresh_from_db()
+        self.assertEqual(revision.content["title"], "I've been edited again!")
+
+    def test_overwrite_non_latest_revision(self):
+        self.child_page.title = "A changed title"
+        user_revision = self.child_page.save_revision(user=self.user)
+        self.child_page.title = "Someone else's changed title"
+        later_revision = self.child_page.save_revision()
+        self.assertEqual(self.child_page.revisions.count(), 3)
+
+        post_data = {
+            "title": "I've been edited again!",
+            "content": "Some content",
+            "slug": "hello-world",
+            "overwrite_revision_id": user_revision.id,
+        }
+        response = self.client.post(
+            reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)),
+            post_data,
+            headers={"Accept": "application/json"},
+        )
+
+        # Should be a 400 response
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response["Content-Type"], "application/json")
+        self.assertEqual(
+            response.json(),
+            {
+                "success": False,
+                "error_code": "invalid_revision",
+                "error_message": "Saving will overwrite a newer version.",
+            },
+        )
+
+        # Page fields should still be from the published version
+        self.child_page.refresh_from_db()
+        self.assertEqual(self.child_page.title, "Hello world!")
+
+        # The passed revision for overwriting, and the actual latest revision, should both be unchanged
+        self.assertEqual(self.child_page.revisions.count(), 3)
+        user_revision.refresh_from_db()
+        self.assertEqual(user_revision.content["title"], "A changed title")
+        later_revision.refresh_from_db()
+        self.assertEqual(
+            later_revision.content["title"], "Someone else's changed title"
+        )
+        self.assertEqual(self.child_page.get_latest_revision().id, later_revision.id)
+
+    def test_get_hydrate_create_view(self):
+        response = self.client.get(
+            reverse("wagtailadmin_pages:edit", args=(self.child_page.id,))
+            + "?_w_hydrate_create_view=1",
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, "wagtailadmin/pages/edit_partials.html")
+        soup = self.get_soup(response.content)
+
+        # Should reload the status and preview side panels
+        side_panels = soup.select(
+            "template[data-controller='w-teleport']"
+            "[data-w-teleport-target-value^='[data-side-panel=']"
+            "[data-w-teleport-mode-value='innerHTML']"
+        )
+        self.assertEqual(len(side_panels), 2)
+        status_side_panel = side_panels[0]
+        self.assertEqual(
+            status_side_panel["data-w-teleport-target-value"],
+            "[data-side-panel='status']",
+        )
+
+        # Under normal circumstances, a newly-created page would never
+        # immediately enter a workflow without a full-page reload, so don't
+        # bother rendering the workflow status dialog when hydrating a create view
+        workflow_status_dialog = soup.find("div", id="workflow-status-dialog")
+        self.assertIsNone(workflow_status_dialog)
+        # However, we should still render the set privacy dialog, since the
+        # user might want to set the page to private immediately after creating it,
+        # and a full-page reload is not required for that
+        set_privacy_dialog = soup.find("div", id="set-privacy")
+        self.assertIsNotNone(set_privacy_dialog)
+
+        # We need to change the preview URL to use the one for editing, but there is
+        # no way to declaratively change attributes via partial rendering yet, and we
+        # need to restart the controller anyway, so just re-render the whole panel
+        preview_side_panel = side_panels[1]
+        self.assertEqual(
+            preview_side_panel["data-w-teleport-target-value"],
+            "[data-side-panel='preview']",
+        )
+        preview_url = reverse(
+            "wagtailadmin_pages:preview_on_edit", args=(self.child_page.id,)
+        )
+        self.assertIsNotNone(
+            preview_side_panel.select_one(f"[data-w-preview-url-value='{preview_url}']")
+        )
+
+        breadcrumbs = soup.find(
+            "template",
+            {
+                "data-controller": "w-teleport",
+                "data-w-teleport-target-value": "header [data-w-breadcrumbs]",
+                "data-w-teleport-mode-value": "outerHTML",
+            },
+        )
+        self.assertIsNotNone(breadcrumbs)
+        # Should include header buttons as they were not rendered in the create view
+        self.assertIsNotNone(breadcrumbs.select_one("#w-slim-header-buttons"))
+
+        # Should render the history link button as it wasn't rendered in the create view
+        history_link = soup.find(
+            "template",
+            {
+                "data-controller": "w-teleport",
+                "data-w-teleport-target-value": "[data-side-panel-toggle]:last-of-type",
+                "data-w-teleport-mode-value": "afterend",
+            },
+        )
+        history_url = reverse("wagtailadmin_pages:history", args=(self.child_page.id,))
+        self.assertIsNotNone(history_link)
+        self.assertIsNotNone(history_link.select_one(f"a[href='{history_url}']"))
+
+        form_title_heading = soup.find(
+            "template",
+            {
+                "data-controller": "w-teleport",
+                "data-w-teleport-target-value": "#header-title span",
+                "data-w-teleport-mode-value": "textContent",
+            },
+        )
+        self.assertIsNone(form_title_heading)
+        header_title = soup.find(
+            "template",
+            {
+                "data-controller": "w-teleport",
+                "data-w-teleport-target-value": "head title",
+                "data-w-teleport-mode-value": "textContent",
+            },
+        )
+        self.assertIsNotNone(header_title)
+        self.assertEqual(
+            header_title.text.strip(),
+            "Editing Simple page: Hello world! (simple page)",
+        )
+
+        # Should include loaded revision ID and timestamp in the form for
+        # subsequent autosave requests
+        form_adds = soup.find(
+            "template",
+            {
+                "data-controller": "w-teleport",
+                "data-w-teleport-target-value": "form[data-edit-form]",
+                "data-w-teleport-mode-value": "afterbegin",
+            },
+        )
+        latest_revision = self.child_page.get_latest_revision()
+        self.assertIsNotNone(form_adds)
+        self.assertEqual(
+            form_adds.select_one("input[name='loaded_revision_id']")["value"],
+            str(latest_revision.pk),
+        )
+        self.assertEqual(
+            form_adds.select_one("input[name='loaded_revision_created_at']")["value"],
+            latest_revision.created_at.isoformat(),
+        )
+
+        # Should load the editing sessions module as it was not in the create view
+        editing_sessions = soup.find(
+            "template",
+            {
+                "data-controller": "w-teleport",
+                "data-w-teleport-target-value": "#w-autosave-indicator",
+                "data-w-teleport-mode-value": "afterend",
+            },
+        )
+        self.assertIsNotNone(editing_sessions)
+        self.assertEqual(
+            editing_sessions.select_one("input[name='revision_id']")["value"],
+            str(latest_revision.pk),
+        )
+        self.assertEqual(
+            editing_sessions.select_one("input[name='revision_created_at']")["value"],
+            latest_revision.created_at.isoformat(),
+        )
+
     def test_page_edit_post_unpublished_page(self):
         # Based on test_page_edit_post(), but tests changes on a draft page vs. live page.
         post_data = {
@@ -648,9 +1249,42 @@ class TestPageEdit(WagtailTestUtils, TestCase):
             reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)), post_data
         )
 
-        # Shouldn't be redirected
-        self.assertContains(response, "The page could not be saved as it is locked")
-
+        # Shouldn't be redirected
+        self.assertContains(response, "The page could not be saved as it is locked")
+
+        # The page shouldn't have "has_unpublished_changes" flag set
+        child_page_new = SimplePage.objects.get(id=self.child_page.id)
+        self.assertFalse(child_page_new.has_unpublished_changes)
+
+    def test_page_edit_post_when_locked_with_json_response(self):
+        # Tests that trying to edit a locked page results in an error
+
+        # Lock the page
+        self.child_page.locked = True
+        self.child_page.save()
+
+        # Post
+        post_data = {
+            "title": "I've been edited!",
+            "content": "Some content",
+            "slug": "hello-world",
+        }
+        response = self.client.post(
+            reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)),
+            post_data,
+            headers={"Accept": "application/json"},
+        )
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(
+            response.json(),
+            {
+                "success": False,
+                "error_code": "locked",
+                "error_message": "The page could not be saved as it is locked.",
+            },
+        )
+
         # The page shouldn't have "has_unpublished_changes" flag set
         child_page_new = SimplePage.objects.get(id=self.child_page.id)
         self.assertFalse(child_page_new.has_unpublished_changes)
@@ -1979,6 +2613,44 @@ class TestPageEdit(WagtailTestUtils, TestCase):
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.content, b"Overridden!")
 
+    def test_before_edit_page_hook_with_json_response(self):
+        def non_json_hook_func(request, page):
+            self.assertIsInstance(request, HttpRequest)
+            self.assertEqual(page.id, self.child_page.id)
+
+            return HttpResponse("Overridden!")
+
+        def json_hook_func(request, page):
+            self.assertIsInstance(request, HttpRequest)
+            self.assertEqual(page.id, self.child_page.id)
+
+            return JsonResponse({"status": "purple"})
+
+        with self.register_hook("before_edit_page", non_json_hook_func):
+            response = self.client.get(
+                reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)),
+                headers={"Accept": "application/json"},
+            )
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(
+            response.json(),
+            {
+                "success": False,
+                "error_code": "blocked_by_hook",
+                "error_message": "Request to edit page was blocked by hook.",
+            },
+        )
+
+        with self.register_hook("before_edit_page", json_hook_func):
+            response = self.client.get(
+                reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)),
+                headers={"Accept": "application/json"},
+            )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"status": "purple"})
+
     def test_before_edit_page_hook_post(self):
         def hook_func(request, page):
             self.assertIsInstance(request, HttpRequest)
@@ -2004,6 +2676,72 @@ class TestPageEdit(WagtailTestUtils, TestCase):
         # page should not be edited
         self.assertEqual(Page.objects.get(id=self.child_page.id).title, "Hello world!")
 
+    def test_before_edit_page_hook_post_with_json_response(self):
+        def non_json_hook_func(request, page):
+            self.assertIsInstance(request, HttpRequest)
+            self.assertEqual(page.id, self.child_page.id)
+
+            return HttpResponse("Overridden!")
+
+        def json_hook_func(request, page):
+            self.assertIsInstance(request, HttpRequest)
+            self.assertEqual(page.id, self.child_page.id)
+
+            return JsonResponse({"status": "purple"})
+
+        with self.register_hook("before_edit_page", non_json_hook_func):
+            post_data = {
+                "title": "I've been edited!",
+                "content": "Some content",
+                "slug": "hello-world-new",
+            }
+            response = self.client.post(
+                reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)),
+                post_data,
+                headers={"Accept": "application/json"},
+            )
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(
+            response.json(),
+            {
+                "success": False,
+                "error_code": "blocked_by_hook",
+                "error_message": "Request to edit page was blocked by hook.",
+            },
+        )
+
+        # page should not be edited
+        self.assertEqual(
+            Page.objects.get(id=self.child_page.id)
+            .get_latest_revision_as_object()
+            .title,
+            "Hello world!",
+        )
+
+        with self.register_hook("before_edit_page", json_hook_func):
+            post_data = {
+                "title": "I've been edited!",
+                "content": "Some content",
+                "slug": "hello-world-new",
+            }
+            response = self.client.post(
+                reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)),
+                post_data,
+                headers={"Accept": "application/json"},
+            )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"status": "purple"})
+
+        # page should not be edited
+        self.assertEqual(
+            Page.objects.get(id=self.child_page.id)
+            .get_latest_revision_as_object()
+            .title,
+            "Hello world!",
+        )
+
     def test_after_edit_page_hook(self):
         def hook_func(request, page):
             self.assertIsInstance(request, HttpRequest)
@@ -2031,6 +2769,66 @@ class TestPageEdit(WagtailTestUtils, TestCase):
             Page.objects.get(id=self.child_page.id).title, "I've been edited!"
         )
 
+    def test_after_edit_page_hook_with_json_response(self):
+        def non_json_hook_func(request, page):
+            self.assertIsInstance(request, HttpRequest)
+            self.assertEqual(page.id, self.child_page.id)
+
+            return HttpResponse("Overridden!")
+
+        def json_hook_func(request, page):
+            self.assertIsInstance(request, HttpRequest)
+            self.assertEqual(page.id, self.child_page.id)
+
+            return JsonResponse({"status": "purple"})
+
+        with self.register_hook("after_edit_page", non_json_hook_func):
+            post_data = {
+                "title": "I've been edited!",
+                "content": "Some content",
+                "slug": "hello-world-new",
+            }
+            response = self.client.post(
+                reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)),
+                post_data,
+                headers={"Accept": "application/json"},
+            )
+
+        self.assertEqual(response.status_code, 200)
+        # hook response is ignored, since it's not a JSON response
+        self.assertEqual(response.json()["success"], True)
+
+        # page should be edited
+        self.assertEqual(
+            Page.objects.get(id=self.child_page.id)
+            .get_latest_revision_as_object()
+            .title,
+            "I've been edited!",
+        )
+
+        with self.register_hook("after_edit_page", json_hook_func):
+            post_data = {
+                "title": "I've been edited again!",
+                "content": "Some content",
+                "slug": "hello-world-new",
+            }
+            response = self.client.post(
+                reverse("wagtailadmin_pages:edit", args=(self.child_page.id,)),
+                post_data,
+                headers={"Accept": "application/json"},
+            )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"status": "purple"})
+
+        # page should be edited
+        self.assertEqual(
+            Page.objects.get(id=self.child_page.id)
+            .get_latest_revision_as_object()
+            .title,
+            "I've been edited again!",
+        )
+
     def test_after_publish_page(self):
         def hook_func(request, page):
             self.assertIsInstance(request, HttpRequest)
@@ -2103,11 +2901,14 @@ class TestPageEdit(WagtailTestUtils, TestCase):
         self.assertIsNotNone(publish_button)
 
     def test_override_publish_action_menu_item_label(self):
+        class CustomPublishMenuItem(PublishMenuItem):
+            label = "Foobar"
+
         def hook_func(menu_items, request, context):
-            for item in menu_items:
-                if item.name == "action-publish":
-                    item.label = "Foobar"
-                    break
+            menu_items[:] = [
+                CustomPublishMenuItem() if item.name == "action-publish" else item
+                for item in menu_items
+            ]
 
         with self.register_hook("construct_page_action_menu", hook_func):
             response = self.client.get(
@@ -2947,7 +3748,7 @@ class TestParentalM2M(WagtailTestUtils, TestCase):
         self.assertIn(self.men_with_beards_category, updated_page.categories.all())
 
 
-class TestValidationErrorMessages(WagtailTestUtils, TestCase):
+class TestValidationerror_messages(WagtailTestUtils, TestCase):
     fixtures = ["test.json"]
 
     def setUp(self):
@@ -3013,6 +3814,46 @@ class TestValidationErrorMessages(WagtailTestUtils, TestCase):
         )
         self.assertIn("This field is required", error_message.get_text())
 
+    def test_field_error_with_json_response(self):
+        post_data = {
+            "title": "",
+            "date_from": "2017-12-25",
+            "slug": "christmas",
+            "audience": "public",
+            "location": "The North Pole",
+            "cost": "Free",
+            "carousel_items-TOTAL_FORMS": 0,
+            "carousel_items-INITIAL_FORMS": 0,
+            "carousel_items-MIN_NUM_FORMS": 0,
+            "carousel_items-MAX_NUM_FORMS": 0,
+            "speakers-TOTAL_FORMS": 0,
+            "speakers-INITIAL_FORMS": 0,
+            "speakers-MIN_NUM_FORMS": 0,
+            "speakers-MAX_NUM_FORMS": 0,
+            "related_links-TOTAL_FORMS": 0,
+            "related_links-INITIAL_FORMS": 0,
+            "related_links-MIN_NUM_FORMS": 0,
+            "related_links-MAX_NUM_FORMS": 0,
+            "head_counts-TOTAL_FORMS": 0,
+            "head_counts-INITIAL_FORMS": 0,
+            "head_counts-MIN_NUM_FORMS": 0,
+            "head_counts-MAX_NUM_FORMS": 0,
+        }
+        response = self.client.post(
+            reverse("wagtailadmin_pages:edit", args=(self.christmas_page.id,)),
+            post_data,
+            headers={"Accept": "application/json"},
+        )
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(
+            response.json(),
+            {
+                "success": False,
+                "error_code": "validation_error",
+                "error_message": "There are validation errors, click save to highlight them.",
+            },
+        )
+
     def test_non_field_error(self):
         """Non-field errors should be shown in the header message"""
         post_data = {
@@ -3231,6 +4072,72 @@ class TestNestedInlinePanel(WagtailTestUtils, TestCase):
         self.assertEqual(awards[0].name, "Beard Of The Century")
         self.assertEqual(awards[1].name, "Bobsleigh Olympic gold medallist")
 
+    def test_post_edit_with_json_response(self):
+        self.christmas_page.unpublish()  # so that draft changes are applied to the database record
+
+        post_data = nested_form_data(
+            {
+                "title": "Christmas",
+                "date_from": "2017-12-25",
+                "date_to": "2017-12-25",
+                "slug": "christmas",
+                "audience": "public",
+                "location": "The North Pole",
+                "cost": "Free",
+                "carousel_items": inline_formset([]),
+                "speakers": inline_formset(
+                    [
+                        {
+                            "id": self.speaker.id,
+                            "first_name": "Jeff",
+                            "last_name": "Christmas",
+                            "awards": inline_formset(
+                                [
+                                    {
+                                        "id": self.speaker.awards.first().id,
+                                        "name": "Beard Of The Century",
+                                        "date_awarded": "1997-12-25",
+                                    },
+                                    {
+                                        "name": "Bobsleigh Olympic gold medallist",
+                                        "date_awarded": "2018-02-01",
+                                    },
+                                ],
+                                initial=1,
+                            ),
+                        },
+                    ],
+                    initial=1,
+                ),
+                "related_links": inline_formset([]),
+                "head_counts": inline_formset([]),
+            }
+        )
+        response = self.client.post(
+            reverse("wagtailadmin_pages:edit", args=(self.christmas_page.id,)),
+            post_data,
+            headers={"Accept": "application/json"},
+        )
+        self.assertEqual(response.status_code, 200)
+        response_json = response.json()
+        self.assertEqual(response_json["success"], True)
+        self.assertEqual(response_json["pk"], self.christmas_page.id)
+        self.christmas_page.refresh_from_db()
+        self.assertEqual(
+            response_json["revision_id"], self.christmas_page.get_latest_revision().pk
+        )
+
+        new_award = self.christmas_page.speakers.first().awards.get(
+            name="Bobsleigh Olympic gold medallist"
+        )
+        self.assertEqual(
+            response_json["field_updates"],
+            {
+                "speakers-0-awards-INITIAL_FORMS": "2",
+                "speakers-0-awards-1-id": str(new_award.id),
+            },
+        )
+
 
 @override_settings(WAGTAIL_I18N_ENABLED=True)
 class TestLocaleSelector(WagtailTestUtils, TestCase):
@@ -3559,6 +4466,76 @@ class TestCommenting(WagtailTestUtils, TestCase):
         self.assertEqual(log_entry.data["comment"]["contentpath"], comment.contentpath)
         self.assertEqual(log_entry.data["comment"]["text"], comment.text)
 
+    def test_new_comment_json(self):
+        post_data = {
+            "title": "I've been edited!",
+            "content": "Some content",
+            "slug": "hello-world",
+            "comments-TOTAL_FORMS": "1",
+            "comments-INITIAL_FORMS": "0",
+            "comments-MIN_NUM_FORMS": "0",
+            "comments-MAX_NUM_FORMS": "",
+            "comments-0-DELETE": "",
+            "comments-0-resolved": "",
+            "comments-0-id": "",
+            "comments-0-contentpath": "title",
+            "comments-0-text": "A test comment",
+            "comments-0-position": "",
+            "comments-0-replies-TOTAL_FORMS": "0",
+            "comments-0-replies-INITIAL_FORMS": "0",
+            "comments-0-replies-MIN_NUM_FORMS": "0",
+            "comments-0-replies-MAX_NUM_FORMS": "0",
+        }
+
+        response = self.client.post(
+            reverse("wagtailadmin_pages:edit", args=[self.child_page.id]),
+            post_data,
+            headers={"Accept": "application/json"},
+        )
+
+        self.assertEqual(response.status_code, 200)
+
+        # Refresh so that latest_revision is correct (instead of using the cached id)
+        self.child_page.refresh_from_db()
+
+        # Check the comment was added
+        comment = self.child_page.wagtail_admin_comments.get()
+        self.assertEqual(comment.text, "A test comment")
+
+        # Should include serialized comments data in the response
+        response_json = response.json()
+        self.assertEqual(response_json["success"], True)
+        self.assertEqual(response_json["pk"], self.child_page.id)
+        comments_json = response_json["comments"]
+        self.assertEqual(len(comments_json["comments"]), 1)
+        comment_json = comments_json["comments"][0]
+        self.assertEqual(comment_json["pk"], comment.pk)
+        self.assertEqual(comment_json["page"], self.child_page.pk)
+        self.assertEqual(comment_json["user"], str(self.user.pk))
+        self.assertEqual(comment_json["text"], "A test comment")
+        self.assertEqual(comment_json["contentpath"], "title")
+        self.assertEqual(comments_json["user"], str(self.user.pk))
+        self.assertIn(str(self.user.pk), comments_json["authors"])
+
+        # Check notification email
+        self.assertEqual(len(mail.outbox), 1)
+        self.assertNeverEmailedWrongUser()
+        self.assertEqual(mail.outbox[0].to, [self.subscriber.email])
+        self.assertEqual(
+            mail.outbox[0].subject,
+            'test@email.com has updated comments on "I\'ve been edited! (simple page)"',
+        )
+        self.assertIn('New comments:\n - "A test comment"\n\n', mail.outbox[0].body)
+
+        # Check audit log
+        log_entry = PageLogEntry.objects.get(action="wagtail.comments.create")
+        self.assertEqual(log_entry.page, self.child_page.page_ptr)
+        self.assertEqual(log_entry.user, self.user)
+        self.assertEqual(log_entry.revision, self.child_page.get_latest_revision())
+        self.assertEqual(log_entry.data["comment"]["id"], comment.id)
+        self.assertEqual(log_entry.data["comment"]["contentpath"], comment.contentpath)
+        self.assertEqual(log_entry.data["comment"]["text"], comment.text)
+
     def test_edit_comment(self):
         comment = Comment.objects.create(
             page=self.child_page,