def setUp(self):
self.root_page = Page.objects.get(id=2)
self.hello_page = SimplePage(
title="Hello world!",
slug="hello-world",
content="hello",
live=False,
)
self.root_page.add_child(instance=self.hello_page)
self.about_page = SimplePage(title="About", slug="about", content="hello")
self.root_page.add_child(instance=self.about_page)
self.administrator = self.create_superuser(
username="******",
email="*****@*****.**",
password="******",
)
self.editor = self.create_user(
username="******", email="*****@*****.**", password="******"
)
sub_editors = Group.objects.create(name="Sub editors")
sub_editors.permissions.add(
Permission.objects.get(
content_type__app_label="wagtailadmin", codename="access_admin"
)
)
self.editor.groups.add(sub_editors)
for permission_type in ["add", "edit", "publish"]:
GroupPagePermission.objects.create(
group=sub_editors, page=self.hello_page, permission_type=permission_type
)
def setUp(self):
self.login()
# Create some pages
self.homepage = Page.objects.get(id=2)
self.public_page = self.homepage.add_child(
instance=SimplePage(
title="Public page",
content="hello",
live=True,
)
)
self.private_page = self.homepage.add_child(
instance=SimplePage(
title="Private page",
content="hello",
live=True,
)
)
PageViewRestriction.objects.create(
page=self.private_page, restriction_type="password", password="******"
)
self.private_child_page = self.private_page.add_child(
instance=SimplePage(
title="Private child page",
content="hello",
live=True,
)
)
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)
# more child pages to test ordering
self.old_page = StandardIndex(
title="Old page",
slug="old-page",
latest_revision_created_at=local_datetime(2010, 1, 1),
)
self.root_page.add_child(instance=self.old_page)
self.new_page = SimplePage(
title="New page",
slug="new-page",
content="hello",
latest_revision_created_at=local_datetime(2016, 1, 1),
)
self.root_page.add_child(instance=self.new_page)
# Login
self.user = self.login()
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 setUp(self):
self.user = self.login()
# Find root page
self.root_page = Page.objects.get(id=2)
# Create a page to unpublish
self.test_page = self.root_page.add_child(instance=SimplePage(
title="Hello world!",
slug="hello-world",
content="hello",
live=True,
has_unpublished_changes=False,
))
# Create a couple of child pages
self.test_child_page = self.test_page.add_child(instance=SimplePage(
title="Child page",
slug="child-page",
content="hello",
live=True,
has_unpublished_changes=True,
))
self.test_another_child_page = self.test_page.add_child(
instance=SimplePage(
title="Another Child page",
slug="another-child-page",
content="hello",
live=True,
has_unpublished_changes=True,
))
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())
def setUp(self):
self.root_page = Page.objects.get(id=2)
# Add child pages which will have already been published before we
# bulk publish them.
self.child_pages = [
SimplePage(
title=f"Hello world!-{i}",
slug=f"hello-world-{i}",
content=f"Hello world {i}!",
live=False,
)
for i in range(1, 5)
]
self.pages_to_be_published = self.child_pages[:3]
self.pages_not_to_be_published = self.child_pages[3:]
for child_page in self.child_pages:
self.root_page.add_child(instance=child_page)
for i, child_page in enumerate(self.child_pages):
child_page.content = f"Hello published world {i}!"
child_page.save_revision()
# Add an additional child page which will be bulk published from a
# draft-only state.
draft_page = SimplePage(
title="Hello world!-5",
slug="hello-world-5",
content="Hello published world 5!",
live=False,
)
self.root_page.add_child(instance=draft_page)
self.child_pages.append(draft_page)
self.pages_to_be_published.append(draft_page)
self.url = (
reverse(
"wagtail_bulk_action",
args=(
"wagtailcore",
"page",
"publish",
),
)
+ "?"
)
for child_page in self.pages_to_be_published:
self.url += f"id={child_page.id}&"
self.redirect_url = reverse("wagtailadmin_explore", args=(self.root_page.id,))
self.user = self.login()
def setUp(self):
# Find root page
self.root_page = Page.objects.get(id=2)
# Add child pages
self.child_pages = [
SimplePage(title=f"Hello world!-{i}",
slug=f"hello-world-{i}",
content=f"hello-{i}") for i in range(1, 5)
]
# first three child pages will be deleted
self.pages_to_be_deleted = self.child_pages[:3]
self.pages_not_to_be_deleted = self.child_pages[3:]
for child_page in self.child_pages:
self.root_page.add_child(instance=child_page)
# map of the form { page: [child_pages] } to be added
self.grandchildren_pages = {
self.pages_to_be_deleted[0]: [
SimplePage(title="Hello world!-a",
slug="hello-world-a",
content="hello-a")
],
self.pages_to_be_deleted[1]: [
SimplePage(title="Hello world!-b",
slug="hello-world-b",
content="hello-b"),
SimplePage(title="Hello world!-c",
slug="hello-world-c",
content="hello-c"),
],
}
for child_page, grandchild_pages in self.grandchildren_pages.items():
for grandchild_page in grandchild_pages:
child_page.add_child(instance=grandchild_page)
self.url = (reverse(
"wagtail_bulk_action",
args=(
"wagtailcore",
"page",
"delete",
),
) + "?")
for child_page in self.pages_to_be_deleted:
self.url += f"&id={child_page.id}"
# Login
self.user = self.login()
def setUp(self):
self.tree_root = Page.objects.get(id=1)
self.home_page = Page.objects.get(id=2)
self.about_page = self.home_page.add_child(
instance=SimplePage(title="About", content="About Foo"))
self.contact_page = self.about_page.add_child(
instance=SimplePage(title="Contact", content="Content Foo"))
self.people_page = self.about_page.add_child(
instance=SimplePage(title="People", content="The people of Foo"))
self.event_index = self.make_event_section("Events")
self.login()
def test_construct_queryset_hook(self):
page = SimplePage(title="Test shown", content="hello")
self.root_page.add_child(instance=page)
page_not_shown = SimplePage(title="Test not shown", content="hello")
self.root_page.add_child(instance=page_not_shown)
def filter_pages(pages, request):
return pages.filter(id=page.id)
with self.register_hook("construct_page_chooser_queryset",
filter_pages):
response = self.get({"q": "Test"})
self.assertEqual(len(response.context["pages"]), 1)
self.assertEqual(response.context["pages"][0].specific, page)
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 test_page_copy_alias_post_without_source_publish_permission(self):
# Check for issue #7293 - If the user has permission to publish at a destination, but not the source.
# Wagtail would crash on attempt to copy
# Create a new section
self.destination_page = self.root_page.add_child(instance=SimplePage(
title="Destination page",
slug="destination-page",
content="hello",
live=True,
has_unpublished_changes=False,
))
# Make user a moderator and make it so they can only publish at the destination page
self.user.is_superuser = False
self.user.groups.add(Group.objects.get(name="Moderators"))
self.user.save()
GroupPagePermission.objects.filter(permission_type="publish").update(
page=self.destination_page)
post_data = {
"new_title": self.test_child_page.title,
"new_slug": self.test_child_page.slug,
"new_parent_page": str(self.destination_page.id),
"copy_subpages": False,
"publish_copies": False,
"alias": False,
}
response = self.client.post(
reverse("wagtailadmin_pages:copy", args=[self.test_child_page.id]),
post_data,
)
# We only need to check that it didn't crash
self.assertEqual(response.status_code, 302)
def test_disable_preview_on_edit(self):
simple_page = SimplePage(title="simple page", content="hello")
self.root_page.add_child(instance=simple_page)
# preview button is available by default
response = self.client.get(
reverse("wagtailadmin_pages:edit", args=(simple_page.id,))
)
self.assertEqual(response.status_code, 200)
preview_url = reverse(
"wagtailadmin_pages:preview_on_edit", args=(simple_page.id,)
)
self.assertContains(response, '<li class="preview">')
self.assertContains(response, 'data-action="%s"' % preview_url)
stream_page = StreamPage(title="stream page", body=[("text", "hello")])
self.root_page.add_child(instance=stream_page)
# StreamPage has preview_modes = []
response = self.client.get(
reverse("wagtailadmin_pages:edit", args=(stream_page.id,))
)
self.assertEqual(response.status_code, 200)
preview_url = reverse(
"wagtailadmin_pages:preview_on_edit", args=(stream_page.id,)
)
self.assertNotContains(response, '<li class="preview">')
self.assertNotContains(response, 'data-action="%s"' % preview_url)
def test_future_go_live_page_will_not_be_published(self):
page = SimplePage(
title="Hello world!",
slug="hello-world",
content="hello",
live=False,
go_live_at=timezone.now() + timedelta(days=1),
)
self.root_page.add_child(instance=page)
page.save_revision(approved_go_live_at=timezone.now() -
timedelta(days=1))
p = Page.objects.get(slug="hello-world")
self.assertFalse(p.live)
self.assertTrue(
PageRevision.objects.filter(page=p).exclude(
approved_go_live_at__isnull=True).exists())
management.call_command("publish_scheduled_pages")
p = Page.objects.get(slug="hello-world")
self.assertFalse(p.live)
self.assertTrue(
PageRevision.objects.filter(page=p).exclude(
approved_go_live_at__isnull=True).exists())
def setUp(self):
self.root_page = Page.objects.get(id=1)
self.home_page = self.root_page.add_child(instance=SimplePage(
title="Homepage", slug="home2", content="hello"))
PageLogEntry.objects.all().delete() # clean up the log entries here.
def make_pages(self):
for i in range(150):
self.root_page.add_child(instance=SimplePage(
title="Page " + str(i),
slug="page-" + str(i),
content="hello",
))
def setUp(self):
# Create pages to unpublish
self.root_page = Page.objects.get(id=2)
self.child_pages = [
SimplePage(title=f"Hello world!-{i}",
slug=f"hello-world-{i}",
content=f"hello-{i}") for i in range(1, 5)
]
# first three child pages will be unpublished
self.pages_to_be_unpublished = self.child_pages[:3]
self.pages_not_to_be_unpublished = self.child_pages[3:]
for child_page in self.child_pages:
self.root_page.add_child(instance=child_page)
self.url = (reverse(
"wagtail_bulk_action",
args=(
"wagtailcore",
"page",
"unpublish",
),
) + "?")
for child_page in self.pages_to_be_unpublished:
self.url += f"&id={child_page.id}"
self.redirect_url = reverse("wagtailadmin_explore",
args=(self.root_page.id, ))
# Login
self.user = self.login()
def test_disable_preview_on_revisions_list(self):
simple_page = SimplePage(title="simple page", content="hello")
self.root_page.add_child(instance=simple_page)
simple_page.save_revision(log_action=True)
# check preview shows up by default
response = self.client.get(
reverse("wagtailadmin_pages:history", args=(simple_page.id,))
)
preview_url = reverse(
"wagtailadmin_pages:revisions_view",
args=(simple_page.id, simple_page.get_latest_revision().id),
)
self.assertContains(response, "Preview")
self.assertContains(response, preview_url)
stream_page = StreamPage(title="stream page", body=[("text", "hello")])
self.root_page.add_child(instance=stream_page)
latest_revision = stream_page.save_revision(log_action=True)
# StreamPage has preview_modes = []
response = self.client.get(
reverse("wagtailadmin_pages:history", args=(stream_page.id,))
)
preview_url = reverse(
"wagtailadmin_pages:revisions_view",
args=(stream_page.id, latest_revision.id),
)
self.assertNotContains(response, "Preview")
self.assertNotContains(response, preview_url)
def create_page(cls):
homepage = Page.objects.get(url_path="/home/")
hello_page = SimplePage(title="Hello world",
slug="hello-world",
content="hello")
homepage.add_child(instance=hello_page)
return hello_page
def setUp(self):
# Create a submitter
submitter = self.create_user(
username="******",
email="*****@*****.**",
password="******",
)
# Find root page
self.root_page = Page.objects.get(id=2)
# Create a page
self.page = SimplePage(
title="Wagtail, the powerful CMS for modern websites",
slug="wagtail",
content="Fast, elegant, open source",
)
self.root_page.add_child(instance=self.page)
# Submit it for moderation
self.page.save_revision(user=submitter, submitted_for_moderation=True)
# Create a revision
self.revision = self.page.get_latest_revision()
self.edit_page_url = reverse("wagtailadmin_pages:edit",
args=(self.revision.page.id, ))
self.preview_page_url = reverse(
"wagtailadmin_pages:preview_for_moderation",
args=(self.revision.id, ))
def test_search_searchable_fields(self):
# Find root page
root_page = Page.objects.get(id=2)
# Create a page
root_page.add_child(instance=SimplePage(
title="Hi there!",
slug="hello-world",
content="good morning",
live=True,
has_unpublished_changes=False,
))
# Confirm the slug is not being searched
response = self.get({"q": "hello"})
self.assertNotContains(response, "There is one matching page")
search_fields = Page.search_fields
# Add slug to the search_fields
Page.search_fields = Page.search_fields + [
SearchField("slug", partial_match=True)
]
# Confirm the slug is being searched
response = self.get({"q": "hello"})
self.assertContains(response, "There is one matching page")
# Reset the search fields
Page.search_fields = search_fields
def test_expired_page_will_be_unpublished(self):
# Connect a mock signal handler to page_unpublished signal
signal_fired = [False]
signal_page = [None]
def page_unpublished_handler(sender, instance, **kwargs):
signal_fired[0] = True
signal_page[0] = instance
page_unpublished.connect(page_unpublished_handler)
page = SimplePage(
title="Hello world!",
slug="hello-world",
content="hello",
live=True,
has_unpublished_changes=False,
expire_at=timezone.now() - timedelta(days=1),
)
self.root_page.add_child(instance=page)
p = Page.objects.get(slug="hello-world")
self.assertTrue(p.live)
management.call_command("publish_scheduled_pages")
p = Page.objects.get(slug="hello-world")
self.assertFalse(p.live)
self.assertTrue(p.has_unpublished_changes)
self.assertTrue(p.expired)
# Check that the page_published signal was fired
self.assertTrue(signal_fired[0])
self.assertEqual(signal_page[0], page)
self.assertEqual(signal_page[0], signal_page[0].specific)
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())
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 test_page_reorder(self):
section_1 = self.root_page.add_child(instance=SimplePage(
title="Child 1", slug="child-1", content="hello"))
self.root_page.add_child(instance=SimplePage(
title="Child 2", slug="child-2", content="hello"))
user = get_user_model().objects.first()
# Reorder section 1 to be the last page under root_page.
# This should log as `wagtail.reorder` because the page was moved under the same parent page
section_1.move(self.root_page, user=user, pos="last-child")
self.assertEqual(
PageLogEntry.objects.filter(action="wagtail.reorder",
user=user).count(), 1)
self.assertEqual(
PageLogEntry.objects.filter(action="wagtail.move",
user=user).count(), 0)
def setUp(self):
self.login()
self.root_page = Page.objects.get(id=2)
self.child_page = self.root_page.add_child(instance=SimplePage(
title="Public page",
content="hello",
live=True,
))
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_assert_can_create_subpage_rules(self):
simple_page = SimplePage(title="Simple Page",
slug="simple",
content="hello")
self.root.add_child(instance=simple_page)
# This should raise an error, as a BusinessChild can not be created under a SimplePage
with self.assertRaisesRegex(
AssertionError,
r"Can not create a tests.businesschild under a tests.simplepage",
):
self.assertCanCreate(simple_page, BusinessChild, {})
def setUpClass(cls):
super().setUpClass()
cls.test_page = SimplePage(title="test", slug="test", content="test")
cls.wagtail_root = Page.get_first_root_node()
cls.wagtail_root.add_child(instance=cls.test_page)
cls.test_page_group = Group.objects.create(name="Test page")
GroupPagePermission.objects.create(
group=cls.test_page_group, page=cls.test_page, permission_type="edit"
)
def setUp(self):
self.root_page = Page.objects.get(id=2)
self.user = self.login()
# SimplePage only has one preview mode
self.single = SimplePage(title="Single preview mode", content="foo")
# MultiPreviewModesPage has two preview modes
self.multiple = MultiPreviewModesPage(title="Multiple preview modes")
self.root_page.add_child(instance=self.single)
self.root_page.add_child(instance=self.multiple)
