def test_get_workflow_from_closest_ancestor(self):
# test that using Page.get_workflow() tries to get the workflow from itself, then the closest ancestor, and does
# not get Workflows from further up the page tree first
workflow_1 = Workflow.objects.create(name="test_workflow_1")
workflow_2 = Workflow.objects.create(name="test_workflow_2")
homepage = Page.objects.get(url_path="/home/")
WorkflowPage.objects.create(page=homepage, workflow=workflow_1)
hello_page = SimplePage(title="Hello world",
slug="hello-world",
content="hello")
homepage.add_child(instance=hello_page)
WorkflowPage.objects.create(page=hello_page, workflow=workflow_2)
goodbye_page = SimplePage(title="Goodbye world",
slug="goodbye-world",
content="goodbye")
hello_page.add_child(instance=goodbye_page)
self.assertEqual(hello_page.get_workflow(), workflow_2)
self.assertEqual(goodbye_page.get_workflow(), workflow_2)
# Check the .all_pages() method
self.assertFalse(
workflow_1.all_pages().filter(id=hello_page.id).exists())
self.assertFalse(
workflow_1.all_pages().filter(id=goodbye_page.id).exists())
self.assertTrue(
workflow_2.all_pages().filter(id=hello_page.id).exists())
self.assertTrue(
workflow_2.all_pages().filter(id=goodbye_page.id).exists())
class TestPageQueryInSite(TestCase):
fixtures = ["test.json"]
def setUp(self):
self.site_2_page = SimplePage(
title="Site 2 page",
slug="site_2_page",
content="Hello",
)
Page.get_first_root_node().add_child(instance=self.site_2_page)
self.site_2_subpage = SimplePage(
title="Site 2 subpage",
slug="site_2_subpage",
content="Hello again",
)
self.site_2_page.add_child(instance=self.site_2_subpage)
self.site_2 = Site.objects.create(
hostname="example.com",
port=8080,
root_page=Page.objects.get(pk=self.site_2_page.pk),
is_default_site=False,
)
self.about_us_page = SimplePage.objects.get(url_path="/home/about-us/")
def test_in_site(self):
site_2_pages = SimplePage.objects.in_site(self.site_2)
self.assertIn(self.site_2_page, site_2_pages)
self.assertIn(self.site_2_subpage, site_2_pages)
self.assertNotIn(self.about_us_page, site_2_pages)
class TestPageDelete(TestCase, WagtailTestUtils):
def setUp(self):
# Find root page
self.root_page = Page.objects.get(id=2)
# Add child page
self.child_page = SimplePage(
title="Hello world!", slug="hello-world", content="hello"
)
self.root_page.add_child(instance=self.child_page)
# Add a page with child pages of its own
self.child_index = StandardIndex(title="Hello index", slug="hello-index")
self.root_page.add_child(instance=self.child_index)
self.grandchild_page = StandardChild(title="Hello Kitty", slug="hello-kitty")
self.child_index.add_child(instance=self.grandchild_page)
# Login
self.user = self.login()
def test_page_delete(self):
response = self.client.get(
reverse("wagtailadmin_pages:delete", args=(self.child_page.id,))
)
self.assertEqual(response.status_code, 200)
# deletion should not actually happen on GET
self.assertTrue(SimplePage.objects.filter(id=self.child_page.id).exists())
@override_settings(WAGTAILADMIN_UNSAFE_PAGE_DELETION_LIMIT=10)
def test_confirm_delete_scenario_1(self):
# If the number of pages to be deleted are less than
# WAGTAILADMIN_UNSAFE_PAGE_DELETION_LIMIT then don't need
# for confirmation
child_1 = SimplePage(title="child 1", slug="child-1", content="hello")
self.child_page.add_child(instance=child_1)
child_2 = SimplePage(title="child 2", slug="child-2", content="hello")
self.child_page.add_child(instance=child_2)
response = self.client.get(
reverse("wagtailadmin_pages:delete", args=(self.child_page.id,))
)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, '<input type="text" name="confirm_site_name"')
# deletion should not actually happen on GET
self.assertTrue(SimplePage.objects.filter(id=self.child_page.id).exists())
# And admin should be able to delete page without any confirmation
response = self.client.post(
reverse("wagtailadmin_pages:delete", args=(self.child_page.id,))
)
# Check that page is deleted
self.assertFalse(SimplePage.objects.filter(id=self.child_page.id).exists())
@override_settings(WAGTAILADMIN_UNSAFE_PAGE_DELETION_LIMIT=3)
@override_settings(WAGTAIL_SITE_NAME="mysite")
def test_confirm_delete_scenario_2(self):
# If the number of pages to be deleted are greater than or equal to
# WAGTAILADMIN_UNSAFE_PAGE_DELETION_LIMIT then show input box
# to input wagtail_site_name.
child_1 = SimplePage(title="child 1", slug="child-1", content="hello")
self.child_page.add_child(instance=child_1)
child_2 = SimplePage(title="child 2", slug="child-2", content="hello")
self.child_page.add_child(instance=child_2)
response = self.client.get(
reverse("wagtailadmin_pages:delete", args=(self.child_page.id,))
)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "This action will delete total <b>3</b> pages.")
self.assertContains(response, "Please type <b>mysite</b> to confirm.")
self.assertContains(response, '<input type="text" name="confirm_site_name"')
# deletion should not actually happen on GET
self.assertTrue(SimplePage.objects.filter(id=self.child_page.id).exists())
@override_settings(WAGTAILADMIN_UNSAFE_PAGE_DELETION_LIMIT=3)
@override_settings(WAGTAIL_SITE_NAME="mysite")
def test_confirm_delete_scenario_3(self):
# If admin entered the incorrect site name and submit
# the form, then site should not be deleted and same
# form should be displayed again.
child_1 = SimplePage(title="child 1", slug="child-1", content="hello")
self.child_page.add_child(instance=child_1)
child_2 = SimplePage(title="child 2", slug="child-2", content="hello")
self.child_page.add_child(instance=child_2)
response = self.client.post(
reverse("wagtailadmin_pages:delete", args=(self.child_page.id,)),
data={"confirm_site_name": "random"},
)
self.assertEqual(response.status_code, 200)
# One error messages should be returned
messages = [m.message for m in response.context["messages"]]
self.assertEqual(len(messages), 1)
self.assertContains(response, "This action will delete total <b>3</b> pages.")
self.assertContains(response, "Please type <b>mysite</b> to confirm.")
self.assertContains(response, '<input type="text" name="confirm_site_name"')
# Site should not be deleted
self.assertTrue(SimplePage.objects.filter(id=self.child_page.id).exists())
@override_settings(WAGTAILADMIN_UNSAFE_PAGE_DELETION_LIMIT=3)
@override_settings(WAGTAIL_SITE_NAME="mysite")
def test_confirm_delete_scenario_4(self):
# If admin entered the correct site name and submit the form
# then the site should be deleted
child_1 = SimplePage(title="child 1", slug="child-1", content="hello")
self.child_page.add_child(instance=child_1)
child_2 = SimplePage(title="child 2", slug="child-2", content="hello")
self.child_page.add_child(instance=child_2)
response = self.client.post(
reverse("wagtailadmin_pages:delete", args=(self.child_page.id,)),
data={"confirm_site_name": "mysite"},
)
# Should be redirected to explorer page
self.assertRedirects(
response, reverse("wagtailadmin_explore", args=(self.root_page.id,))
)
# Check that the page is deleted
self.assertFalse(SimplePage.objects.filter(id=self.child_page.id).exists())
# Check that the subpage is also deleted
self.assertFalse(SimplePage.objects.filter(id=child_1.id).exists())
self.assertFalse(SimplePage.objects.filter(id=child_2.id).exists())
def test_page_delete_specific_admin_title(self):
response = self.client.get(
reverse("wagtailadmin_pages:delete", args=(self.child_page.id,))
)
self.assertEqual(response.status_code, 200)
# The admin_display_title specific to ChildPage is shown on the delete confirmation page.
self.assertContains(response, self.child_page.get_admin_display_title())
def test_page_delete_bad_permissions(self):
# Remove privileges from user
self.user.is_superuser = False
self.user.user_permissions.add(
Permission.objects.get(
content_type__app_label="wagtailadmin", codename="access_admin"
)
)
self.user.save()
# Get delete page
response = self.client.get(
reverse("wagtailadmin_pages:delete", args=(self.child_page.id,))
)
# Check that the user received a 302 redirect response
self.assertEqual(response.status_code, 302)
# Check that the deletion has not happened
self.assertTrue(SimplePage.objects.filter(id=self.child_page.id).exists())
def test_page_delete_post(self):
# Connect a mock signal handler to page_unpublished signal
mock_handler = mock.MagicMock()
page_unpublished.connect(mock_handler)
# Post
response = self.client.post(
reverse("wagtailadmin_pages:delete", args=(self.child_page.id,))
)
# Should be redirected to explorer page
self.assertRedirects(
response, reverse("wagtailadmin_explore", args=(self.root_page.id,))
)
# treebeard should report no consistency problems with the tree
self.assertFalse(
any(Page.find_problems()), "treebeard found consistency problems"
)
# Check that the page is gone
self.assertEqual(
Page.objects.filter(
path__startswith=self.root_page.path, slug="hello-world"
).count(),
0,
)
# Check that the page_unpublished signal was fired
self.assertEqual(mock_handler.call_count, 1)
mock_call = mock_handler.mock_calls[0][2]
self.assertEqual(mock_call["sender"], self.child_page.specific_class)
self.assertEqual(mock_call["instance"], self.child_page)
self.assertIsInstance(mock_call["instance"], self.child_page.specific_class)
def test_page_delete_notlive_post(self):
# Same as above, but this makes sure the page_unpublished signal is not fired
# when if the page is not live when it is deleted
# Unpublish the page
self.child_page.live = False
self.child_page.save()
# Connect a mock signal handler to page_unpublished signal
mock_handler = mock.MagicMock()
page_unpublished.connect(mock_handler)
# Post
response = self.client.post(
reverse("wagtailadmin_pages:delete", args=(self.child_page.id,))
)
# Should be redirected to explorer page
self.assertRedirects(
response, reverse("wagtailadmin_explore", args=(self.root_page.id,))
)
# treebeard should report no consistency problems with the tree
self.assertFalse(
any(Page.find_problems()), "treebeard found consistency problems"
)
# Check that the page is gone
self.assertEqual(
Page.objects.filter(
path__startswith=self.root_page.path, slug="hello-world"
).count(),
0,
)
# Check that the page_unpublished signal was not fired
self.assertEqual(mock_handler.call_count, 0)
def test_subpage_deletion(self):
# Connect mock signal handlers to page_unpublished, pre_delete and post_delete signals
unpublish_signals_received = []
pre_delete_signals_received = []
post_delete_signals_received = []
def page_unpublished_handler(sender, instance, **kwargs):
unpublish_signals_received.append((sender, instance.id))
def pre_delete_handler(sender, instance, **kwargs):
pre_delete_signals_received.append((sender, instance.id))
def post_delete_handler(sender, instance, **kwargs):
post_delete_signals_received.append((sender, instance.id))
page_unpublished.connect(page_unpublished_handler)
pre_delete.connect(pre_delete_handler)
post_delete.connect(post_delete_handler)
# Post
response = self.client.post(
reverse("wagtailadmin_pages:delete", args=(self.child_index.id,))
)
# Should be redirected to explorer page
self.assertRedirects(
response, reverse("wagtailadmin_explore", args=(self.root_page.id,))
)
# treebeard should report no consistency problems with the tree
self.assertFalse(
any(Page.find_problems()), "treebeard found consistency problems"
)
# Check that the page is gone
self.assertFalse(StandardIndex.objects.filter(id=self.child_index.id).exists())
self.assertFalse(Page.objects.filter(id=self.child_index.id).exists())
# Check that the subpage is also gone
self.assertFalse(
StandardChild.objects.filter(id=self.grandchild_page.id).exists()
)
self.assertFalse(Page.objects.filter(id=self.grandchild_page.id).exists())
# Check that the signals were fired for both pages
self.assertIn((StandardIndex, self.child_index.id), unpublish_signals_received)
self.assertIn(
(StandardChild, self.grandchild_page.id), unpublish_signals_received
)
self.assertIn((StandardIndex, self.child_index.id), pre_delete_signals_received)
self.assertIn(
(StandardChild, self.grandchild_page.id), pre_delete_signals_received
)
self.assertIn(
(StandardIndex, self.child_index.id), post_delete_signals_received
)
self.assertIn(
(StandardChild, self.grandchild_page.id), post_delete_signals_received
)
def test_before_delete_page_hook(self):
def hook_func(request, page):
self.assertIsInstance(request, HttpRequest)
self.assertEqual(page.id, self.child_page.id)
return HttpResponse("Overridden!")
with self.register_hook("before_delete_page", hook_func):
response = self.client.get(
reverse("wagtailadmin_pages:delete", args=(self.child_page.id,))
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"Overridden!")
def test_before_delete_page_hook_post(self):
def hook_func(request, page):
self.assertIsInstance(request, HttpRequest)
self.assertEqual(page.id, self.child_page.id)
return HttpResponse("Overridden!")
with self.register_hook("before_delete_page", hook_func):
response = self.client.post(
reverse("wagtailadmin_pages:delete", args=(self.child_page.id,))
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"Overridden!")
# page should not be deleted
self.assertTrue(Page.objects.filter(id=self.child_page.id).exists())
def test_after_delete_page_hook(self):
def hook_func(request, page):
self.assertIsInstance(request, HttpRequest)
self.assertEqual(page.id, self.child_page.id)
return HttpResponse("Overridden!")
with self.register_hook("after_delete_page", hook_func):
response = self.client.post(
reverse("wagtailadmin_pages:delete", args=(self.child_page.id,))
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"Overridden!")
# page should be deleted
self.assertFalse(Page.objects.filter(id=self.child_page.id).exists())
class TestPageSlugChangedSignal(TestCase, WagtailTestUtils):
"""
Tests for the `wagtail.signals.page_slug_changed` signal
"""
def setUp(self):
# Find root page
site = Site.objects.select_related("root_page").get(is_default_site=True)
root_page = site.root_page
# Create two sections
self.section_a = SimplePage(
title="Section A", slug="section-a", content="hello"
)
root_page.add_child(instance=self.section_a)
self.section_b = SimplePage(
title="Section B", slug="section-b", content="hello"
)
root_page.add_child(instance=self.section_b)
# Add test page to section A
self.test_page = SimplePage(
title="Hello world! A", slug="hello-world-a", content="hello"
)
self.section_a.add_child(instance=self.test_page)
def test_signal_emitted_on_slug_change(self):
# Connect a mock signal handler to the signal
handler = mock.MagicMock()
page_slug_changed.connect(handler)
old_page = SimplePage.objects.get(id=self.test_page.id)
try:
self.test_page.slug = "updated"
self.test_page.save()
# TODO: When Django 3.1< support is dropped, wrap save in
# self.captureOnCommitCallbacks and remove this code
for _, func in connection.run_on_commit:
func()
finally:
# Disconnect mock handler to prevent cross-test pollution
page_slug_changed.disconnect(handler)
# Check the signal was fired
self.assertEqual(handler.call_count, 1)
self.assertTrue(
handler.called_with(
sender=SimplePage,
instance=self.test_page,
instance_before=old_page,
)
)
def test_signal_not_emitted_on_title_change(self):
# Connect a mock signal handler to the signal
handler = mock.MagicMock()
page_slug_changed.connect(handler)
try:
self.test_page.title = "Goodnight Moon!"
self.test_page.save()
# NOTE: Even though we're not expecting anything to happen here,
# we need to invoke the callbacks in run_on_commit the same way
# the same way we do in ``test_signal_emitted_on_slug_change``,
# otherwise this test wouldn't prove anything.
for _, func in connection.run_on_commit:
func()
finally:
# Disconnect mock handler to prevent cross-test pollution
page_slug_changed.disconnect(handler)
# Check the signal was NOT fired
self.assertEqual(handler.call_count, 0)
def test_signal_not_emitted_on_page_move(self):
# Connect a mock signal handler to the signal
handler = mock.MagicMock()
page_slug_changed.connect(handler)
try:
self.test_page.move(self.section_b, pos="last-child")
# NOTE: Even though we're not expecting anything to happen here,
# we need to invoke the callbacks in run_on_commit the same way
# the same way we do in ``test_signal_emitted_on_slug_change``,
# otherwise this test wouldn't prove anything.
for _, func in connection.run_on_commit:
func()
finally:
# Disconnect mock handler to prevent cross-test pollution
page_slug_changed.disconnect(handler)
# Check the signal was NOT fired
self.assertEqual(handler.call_count, 0)
class TestChooserBrowseChild(TestCase, WagtailTestUtils):
def setUp(self):
self.root_page = Page.objects.get(id=2)
# Add child page
self.child_page = SimplePage(title="foobarbaz", content="hello")
self.root_page.add_child(instance=self.child_page)
self.login()
def get(self, params={}):
return self.client.get(
reverse("wagtailadmin_choose_page_child",
args=(self.root_page.id, )), params)
def get_invalid(self, params={}):
return self.client.get(
reverse("wagtailadmin_choose_page_child", args=(9999999, )),
params)
def test_simple(self):
response = self.get()
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "wagtailadmin/chooser/browse.html")
def test_get_invalid(self):
self.assertEqual(self.get_invalid().status_code, 404)
def test_with_page_type(self):
# Add a page that is not a SimplePage
event_page = EventPage(
title="event",
location="the moon",
audience="public",
cost="free",
date_from="2001-01-01",
)
self.root_page.add_child(instance=event_page)
# Add a page with a child page
event_index_page = EventIndex(title="events", )
self.root_page.add_child(instance=event_index_page)
event_index_page.add_child(instance=EventPage(
title="other event",
location="the moon",
audience="public",
cost="free",
date_from="2001-01-01",
))
# Send request
response = self.get({"page_type": "tests.simplepage"})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "wagtailadmin/chooser/browse.html")
self.assertEqual(response.context["page_type_string"],
"tests.simplepage")
pages = {
page.id: page
for page in response.context["pages"].object_list
}
# Child page is a simple page directly underneath root
# so should appear in the list
self.assertIn(self.child_page.id, pages)
self.assertTrue(pages[self.child_page.id].can_choose)
self.assertFalse(pages[self.child_page.id].can_descend)
# Event page is not a simple page and is not descendable either
# so should not appear in the list
self.assertNotIn(event_page.id, pages)
# Event index page is not a simple page but has a child and is therefore descendable
# so should appear in the list
self.assertIn(event_index_page.id, pages)
self.assertFalse(pages[event_index_page.id].can_choose)
self.assertTrue(pages[event_index_page.id].can_descend)
def test_with_url_extended_page_type(self):
# Add a page that overrides the url path
single_event_page = SingleEventPage(
title="foo",
location="the moon",
audience="public",
cost="free",
date_from="2001-01-01",
)
self.root_page.add_child(instance=single_event_page)
# Send request
response = self.get()
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "wagtailadmin/chooser/browse.html")
page_urls = [page.url for page in response.context["pages"]]
self.assertIn("/foo/pointless-suffix/", page_urls)
def test_with_blank_page_type(self):
# a blank page_type parameter should be equivalent to an absent parameter
# (or an explicit page_type of wagtailcore.page)
response = self.get({"page_type": ""})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "wagtailadmin/chooser/browse.html")
def test_with_multiple_page_types(self):
# Add a page that is not a SimplePage
event_page = EventPage(
title="event",
location="the moon",
audience="public",
cost="free",
date_from="2001-01-01",
)
self.root_page.add_child(instance=event_page)
# Send request
response = self.get({"page_type": "tests.simplepage,tests.eventpage"})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "wagtailadmin/chooser/browse.html")
self.assertEqual(response.context["page_type_string"],
"tests.simplepage,tests.eventpage")
pages = {
page.id: page
for page in response.context["pages"].object_list
}
# Simple page in results, as before
self.assertIn(self.child_page.id, pages)
self.assertTrue(pages[self.child_page.id].can_choose)
# Event page should now also be choosable
self.assertIn(event_page.id, pages)
self.assertTrue(pages[self.child_page.id].can_choose)
def test_with_unknown_page_type(self):
response = self.get({"page_type": "foo.bar"})
self.assertEqual(response.status_code, 404)
def test_with_bad_page_type(self):
response = self.get({"page_type": "wagtailcore.site"})
self.assertEqual(response.status_code, 404)
def test_with_invalid_page_type(self):
response = self.get({"page_type": "foo"})
self.assertEqual(response.status_code, 404)
def test_with_admin_display_title(self):
# Check the display of the child page title when it's a child
response = self.get({"page_type": "wagtailcore.Page"})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "wagtailadmin/chooser/browse.html")
html = response.json().get("html")
self.assertInHTML("foobarbaz (simple page)", html)
# The data-title attribute should not use the custom admin display title,
# because JS code that uses that attribute (e.g. the rich text editor)
# should use the real page title.
self.assertIn('data-title="foobarbaz"', html)
def test_parent_with_admin_display_title(self):
# Add another child under child_page so it renders a chooser list
leaf_page = SimplePage(title="quux", content="goodbye")
self.child_page.add_child(instance=leaf_page)
# Use the child page as the chooser parent
response = self.client.get(
reverse("wagtailadmin_choose_page_child",
args=(self.child_page.id, )),
params={"page_type": "wagtailcore.Page"},
)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "wagtailadmin/chooser/browse.html")
self.assertInHTML("foobarbaz (simple page)",
response.json().get("html"))
self.assertInHTML("quux (simple page)", response.json().get("html"))
def test_admin_display_title_breadcrumb(self):
# Add another child under child_page so we get breadcrumbs
leaf_page = SimplePage(title="quux", content="goodbye")
self.child_page.add_child(instance=leaf_page)
# Use the leaf page as the chooser parent, so child is in the breadcrumbs
response = self.client.get(
reverse("wagtailadmin_choose_page_child", args=(leaf_page.id, )))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "wagtailadmin/chooser/browse.html")
# Look for a link element in the breadcrumbs with the admin title
expected = """
<li class="breadcrumb-item">
<a href="/admin/choose-page/{page_id}/?" class="breadcrumb-link navigate-pages">{page_title}
<svg class="icon icon-arrow-right arrow_right_icon" aria-hidden="true">
<use href="#icon-arrow-right"></use>
</svg>
</a>
</li>
""".format(
page_id=self.child_page.id,
page_title="foobarbaz (simple page)",
)
self.assertTagInHTML(expected, response.json().get("html"))
def setup_pagination_test_data(self):
# Create lots of pages
for i in range(100):
new_page = SimplePage(
title="foobarbaz",
slug="foobarbaz-%d" % i,
content="hello",
)
self.root_page.add_child(instance=new_page)
def test_pagination_basic(self):
self.setup_pagination_test_data()
response = self.get()
self.assertEqual(response.context["pages"].paginator.num_pages, 5)
self.assertEqual(response.context["pages"].number, 1)
def test_pagination_another_page(self):
self.setup_pagination_test_data()
response = self.get({"p": 2})
self.assertEqual(response.context["pages"].number, 2)
def test_pagination_invalid_page(self):
self.setup_pagination_test_data()
response = self.get({"p": "foo"})
self.assertEqual(response.context["pages"].number, 1)
def test_pagination_out_of_range_page(self):
self.setup_pagination_test_data()
response = self.get({"p": 100})
self.assertEqual(response.context["pages"].number, 5)
class TestPageReorder(TestCase, WagtailTestUtils):
fixtures = ["test.json"]
def __init__(self, methodName: str = ...) -> None:
super().__init__(methodName)
def setUp(self):
# Find root page
self.root_page = Page.objects.get(id=2)
# root
# |- simple_index (SimplePage)
# | |- simple_child_1 (SimplePage)
# | |- simple_child_2 (SimplePage)
# | |- simple_child_3 (SimplePage)
self.index_page = SimplePage(title="Simple",
slug="simple",
content="hello")
self.root_page.add_child(instance=self.index_page)
self.child_1 = SimplePage(title="Child 1 of SimplePage",
slug="child-1",
content="hello")
self.index_page.add_child(instance=self.child_1)
self.child_2 = SimplePage(title="Child 2 of SimplePage",
slug="child-2",
content="hello")
self.index_page.add_child(instance=self.child_2)
self.child_3 = SimplePage(title="Child 3 of SimplePage",
slug="child-3",
content="hello")
self.index_page.add_child(instance=self.child_3)
# Login
self.user = self.login()
def test_page_set_page_position_get_request_with_simple_page(self):
"""
Test that GET requests to set_page_position view don't alter the page order.
"""
response = self.client.get(
reverse("wagtailadmin_pages:set_page_position",
args=(self.child_1.id, )))
self.assertEqual(response.status_code, 200)
# Ensure page order does not change:
child_slugs = self.index_page.get_children().values_list("slug",
flat=True)
self.assertListEqual(list(child_slugs),
["child-1", "child-2", "child-3"])
def test_page_set_page_position_without_position_argument_moves_it_to_the_end(
self):
response = self.client.post(
reverse("wagtailadmin_pages:set_page_position",
args=(self.child_1.id, )))
self.assertEqual(response.status_code, 200)
# check if child_1 is the last child page:
child_slugs = self.index_page.get_children().values_list("slug",
flat=True)
self.assertListEqual(list(child_slugs),
["child-2", "child-3", "child-1"])
def test_page_move_page_position_up(self):
"""Moves child 3 to the first position."""
response = self.client.post(
reverse("wagtailadmin_pages:set_page_position",
args=(self.child_3.id, )) + "?position=0")
self.assertEqual(response.status_code, 200)
# check if child_3 is the first child page:
child_slugs = self.index_page.get_children().values_list("slug",
flat=True)
self.assertListEqual(list(child_slugs),
["child-3", "child-1", "child-2"])
def test_page_move_page_position_down(self):
"""
Moves child 3 to the first position."""
response = self.client.post(
reverse("wagtailadmin_pages:set_page_position",
args=(self.child_1.id, )) + "?position=1")
self.assertEqual(response.status_code, 200)
# check if child_1 is the second child page:
child_slugs = self.index_page.get_children().values_list("slug",
flat=True)
self.assertListEqual(list(child_slugs),
["child-2", "child-1", "child-3"])
def test_page_move_page_position_to_the_same_position(self):
"""
Moves child 3 to the first position."""
response = self.client.post(
reverse("wagtailadmin_pages:set_page_position",
args=(self.child_1.id, )) + "?position=0")
self.assertEqual(response.status_code, 200)
# Ensure page order does not change:
child_slugs = self.index_page.get_children().values_list("slug",
flat=True)
self.assertListEqual(list(child_slugs),
["child-1", "child-2", "child-3"])
def test_page_set_page_position_with_invalid_target_position(self):
response = self.client.post(
reverse("wagtailadmin_pages:set_page_position",
args=(self.child_3.id, )) + "?position=99")
self.assertEqual(response.status_code, 200)
# Ensure page order does not change:
child_slugs = self.index_page.get_children().values_list("slug",
flat=True)
self.assertListEqual(list(child_slugs),
["child-1", "child-2", "child-3"])
class TestPageMove(TestCase, WagtailTestUtils):
fixtures = ["test.json"]
def setUp(self):
# Find root page
self.root_page = Page.objects.get(id=2)
# Create three sections
self.section_a = SimplePage(title="Section A",
slug="section-a",
content="hello")
self.root_page.add_child(instance=self.section_a)
self.section_b = SimplePage(title="Section B",
slug="section-b",
content="hello")
self.root_page.add_child(instance=self.section_b)
self.section_c = SimplePage(title="Section C",
slug="section-c",
content="hello")
self.root_page.add_child(instance=self.section_c)
# Add test page A into section A
self.test_page_a = SimplePage(title="Hello world!",
slug="hello-world",
content="hello")
self.section_a.add_child(instance=self.test_page_a)
# Add test page B into section C
self.test_page_b = SimplePage(title="Hello world!",
slug="hello-world",
content="hello")
self.section_c.add_child(instance=self.test_page_b)
# Add unpublished page to the root with a child page
self.unpublished_page = SimplePage(title="Unpublished",
slug="unpublished",
content="hello")
sub_page = SimplePage(title="Sub Page",
slug="sub-page",
content="child")
self.root_page.add_child(instance=self.unpublished_page)
self.unpublished_page.add_child(instance=sub_page)
# unpublish pages last (used to validate the edit only permission)
self.unpublished_page.unpublish()
sub_page.unpublish()
# Login
self.user = self.login()
def test_page_move(self):
response = self.client.get(
reverse("wagtailadmin_pages:move", args=(self.test_page_a.id, )))
self.assertEqual(response.status_code, 200)
def test_page_move_bad_permissions(self):
# Remove privileges from user
self.user.is_superuser = False
self.user.user_permissions.add(
Permission.objects.get(content_type__app_label="wagtailadmin",
codename="access_admin"))
self.user.save()
# Get move page
response = self.client.get(
reverse("wagtailadmin_pages:move", args=(self.test_page_a.id, )))
# Check that the user received a 302 redirected response
self.assertEqual(response.status_code, 302)
def test_user_without_bulk_delete_permission_can_move(self):
# to verify that a user without bulk delete permission is able to move a page with a child page
self.client.logout()
user = get_user_model().objects.get(email="*****@*****.**")
self.login(user)
# ensure the bulk_delete is not applicable to this user
can_bulk_delete = self.test_page_b.permissions_for_user(
user).can_delete()
self.assertFalse(can_bulk_delete)
response = self.client.get(
reverse("wagtailadmin_pages:move",
args=(self.unpublished_page.id, )))
self.assertEqual(response.status_code, 200)
def test_page_move_confirm(self):
response = self.client.get(
reverse(
"wagtailadmin_pages:move_confirm",
args=(self.test_page_a.id, self.section_b.id),
))
self.assertEqual(response.status_code, 200)
response = self.client.get(
reverse(
"wagtailadmin_pages:move_confirm",
args=(self.test_page_b.id, self.section_a.id),
))
# Duplicate slugs triggers a redirect with an error message.
self.assertEqual(response.status_code, 302)
response = self.client.get(reverse("wagtailadmin_home"))
messages = list(response.context["messages"])
self.assertEqual(len(messages), 1)
self.assertEqual(messages[0].level, message_constants.ERROR)
# Slug should be in error message.
self.assertIn("{}".format(self.test_page_b.slug), messages[0].message)
def test_move_triggers_signals(self):
# Connect a mock signal handler to pre_page_move and post_page_move signals
pre_moved_handler = mock.MagicMock()
post_moved_handler = mock.MagicMock()
pre_page_move.connect(pre_moved_handler)
post_page_move.connect(post_moved_handler)
# Post to view to move page
try:
self.client.post(
reverse(
"wagtailadmin_pages:move_confirm",
args=(self.test_page_a.id, self.section_b.id),
))
finally:
# Disconnect mock handler to prevent cross-test pollution
pre_page_move.disconnect(pre_moved_handler)
post_page_move.disconnect(post_moved_handler)
# Check that the pre_page_move signal was fired
self.assertEqual(pre_moved_handler.call_count, 1)
self.assertTrue(
pre_moved_handler.called_with(
sender=self.test_page_a.specific_class,
instance=self.test_page_a,
parent_page_before=self.section_a,
parent_page_after=self.section_b,
url_path_before="/home/section-a/hello-world/",
url_path_after="/home/section-b/hello-world/",
))
# Check that the post_page_move signal was fired
self.assertEqual(post_moved_handler.call_count, 1)
self.assertTrue(
post_moved_handler.called_with(
sender=self.test_page_a.specific_class,
instance=self.test_page_a,
parent_page_before=self.section_a,
parent_page_after=self.section_b,
url_path_before="/home/section-a/hello-world/",
url_path_after="/home/section-b/hello-world/",
))
def test_before_move_page_hook(self):
def hook_func(request, page, destination):
self.assertIsInstance(request, HttpRequest)
self.assertIsInstance(page.specific, SimplePage)
self.assertIsInstance(destination.specific, SimplePage)
return HttpResponse("Overridden!")
with self.register_hook("before_move_page", hook_func):
response = self.client.get(
reverse(
"wagtailadmin_pages:move_confirm",
args=(self.test_page_a.id, self.section_b.id),
))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"Overridden!")
def test_before_move_page_hook_post(self):
def hook_func(request, page, destination):
self.assertIsInstance(request, HttpRequest)
self.assertIsInstance(page.specific, SimplePage)
self.assertIsInstance(destination.specific, SimplePage)
return HttpResponse("Overridden!")
with self.register_hook("before_move_page", hook_func):
response = self.client.post(
reverse(
"wagtailadmin_pages:move_confirm",
args=(self.test_page_a.id, self.section_b.id),
))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"Overridden!")
# page should not be moved
self.assertEqual(
Page.objects.get(id=self.test_page_a.id).get_parent().id,
self.section_a.id)
def test_after_move_page_hook(self):
def hook_func(request, page):
self.assertIsInstance(request, HttpRequest)
self.assertIsInstance(page.specific, SimplePage)
return HttpResponse("Overridden!")
with self.register_hook("after_move_page", hook_func):
response = self.client.post(
reverse(
"wagtailadmin_pages:move_confirm",
args=(self.test_page_a.id, self.section_b.id),
))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"Overridden!")
# page should be moved
self.assertEqual(
Page.objects.get(id=self.test_page_a.id).get_parent().id,
self.section_b.id)
