def test_bulk_move_slug_already_taken(self):
temp_page_1 = SimplePage(title="Hello world!",
slug="hello-world-b",
content="hello")
temp_page_2 = SimplePage(title="Hello world!",
slug="hello-world-b-1",
content="hello")
self.section_b.add_child(instance=temp_page_1)
self.section_b.add_child(instance=temp_page_2)
response = self.client.post(self.url, {'chooser': self.section_b.id})
html = response.content.decode()
self.assertInHTML(
'<p>The following pages cannot be moved due to duplicate slugs</p>',
html)
for child_page in self.pages_to_be_moved:
self.assertInHTML(
'<li><a href="{edit_page_url}" target="_blank" rel="noopener noreferrer">{page_title}</a></li>'
.format(edit_page_url=reverse('wagtailadmin_pages:edit',
args=[child_page.id]),
page_title=child_page.title), html)
def setUp(self):
# Find root page
self.root_page = Page.objects.get(id=2)
# Login
self.user = self.login()
# Create a page and submit it for moderation
self.child_page = SimplePage(
title="Hello world!",
slug='hello-world',
content="hello",
live=False,
)
self.root_page.add_child(instance=self.child_page)
def test_no_thousand_separators_in_bulk_action_checkbox(self):
"""
Test that the USE_THOUSAND_SEPARATOR setting does mess up object IDs in
bulk actions checkboxes
"""
self.root_page.add_child(instance=SimplePage(
pk=1000,
title="Page 1000",
slug="page-1000",
content="hello",
))
response = self.client.get(
reverse("wagtailadmin_explore", args=(self.root_page.id, )))
expected = 'data-object-id="1000"'
self.assertContains(response, expected)
def test_page_delete(self):
self.home_page.add_child(instance=SimplePage(
title="Child", slug="child-page", content="hello"))
child = self.home_page.add_child(instance=SimplePage(
title="Another child", slug="child-page-2", content="hello"))
child.delete()
self.assertEqual(
PageLogEntry.objects.filter(action="wagtail.delete").count(), 1)
# check deleting a parent page logs child deletion
self.home_page.delete()
self.assertEqual(
PageLogEntry.objects.filter(action="wagtail.delete").count(), 3)
self.assertListEqual(
list(
PageLogEntry.objects.filter(
action="wagtail.delete").values_list("label", flat=True)),
[
"Homepage (simple page)",
"Child (simple page)",
"Another child (simple page)",
],
)
def test_page_move(self):
section = self.root_page.add_child(instance=SimplePage(
title="About us", slug="about", content="hello"))
user = get_user_model().objects.first()
# move() interprets `target` as an intended 'sibling' by default, so
# we must use `pos` to indicate that `self.home_page` should be the
# new 'parent'
section.move(self.home_page, pos="last-child", user=user)
self.assertEqual(
PageLogEntry.objects.filter(action='wagtail.move',
user=user).count(), 1)
self.assertEqual(
PageLogEntry.objects.filter(action='wagtail.reorder',
user=user).count(), 0)
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, 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)
# 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)
# Login
self.user = self.login()
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_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.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 setUp(self):
# Find root page
self.root_page = Page.objects.get(id=2)
# Add child page
child_page = SimplePage(
title="Hello world!",
slug="hello-world",
content="Some content here",
)
self.root_page.add_child(instance=child_page)
child_page.save_revision().publish()
self.child_page = SimplePage.objects.get(id=child_page.id)
self.create_superuser(username='******', password='******')
self.create_superuser(username='******', password='******')
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 alias page
self.alias_page = self.child_page.create_alias(
update_slug="alias-page")
# Login
self.user = self.login()
def test_future_expired_page_will_not_be_unpublished(self):
page = SimplePage(
title="Hello world!",
slug="hello-world",
live=True,
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.assertTrue(p.live)
self.assertFalse(p.expired)
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 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_go_live_page_will_be_published(self):
# Connect a mock signal handler to page_published signal
signal_fired = [False]
signal_page = [None]
def page_published_handler(sender, instance, **kwargs):
signal_fired[0] = True
signal_page[0] = instance
page_published.connect(page_published_handler)
page = SimplePage(
title="Hello world!",
slug="hello-world",
content="hello",
live=False,
has_unpublished_changes=True,
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.assertTrue(p.live)
self.assertTrue(p.first_published_at)
self.assertFalse(p.has_unpublished_changes)
self.assertFalse(
PageRevision.objects.filter(page=p).exclude(
approved_go_live_at__isnull=True).exists())
# 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_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
self.assertTagInHTML(
'<li><a href="/admin/choose-page/{page_id}/?" class="navigate-pages">{page_title}</a></li>'
.format(
page_id=self.child_page.id,
page_title="foobarbaz (simple page)",
),
response.json().get('html'))
def setUp(self):
# Login.
self.user = self.login()
# Find root page.
self.root_page = Page.objects.get(id=2)
# Add child page.
self.child_page = SimplePage(
title='Test Page',
slug='test-page',
)
self.root_page.add_child(instance=self.child_page)
# Create revisions.
for i in range(20):
self.child_page.save_revision(user=self.user,
submitted_for_moderation=False,
approved_go_live_at=None)
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)
# create user with admin access (but not draft_view access)
user = get_user_model().objects.create_user(username='******',
email='*****@*****.**',
password='******')
user.user_permissions.add(
Permission.objects.get(content_type__app_label='wagtailadmin',
codename='access_admin'))
def test_expired_pages_are_dropped_from_mod_queue(self):
page = SimplePage(
title="Hello world!",
slug="hello-world",
content="hello",
live=False,
expire_at=timezone.now() - timedelta(days=1),
)
self.root_page.add_child(instance=page)
page.save_revision(submitted_for_moderation=True)
p = Page.objects.get(slug='hello-world')
self.assertFalse(p.live)
self.assertTrue(PageRevision.objects.filter(page=p, submitted_for_moderation=True).exists())
management.call_command('publish_scheduled_pages')
p = Page.objects.get(slug='hello-world')
self.assertFalse(PageRevision.objects.filter(page=p, submitted_for_moderation=True).exists())
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()
# check preview shows up by default
response = self.client.get(reverse('wagtailadmin_pages:revisions_index', 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()
# StreamPage has preview_modes = []
response = self.client.get(reverse('wagtailadmin_pages:revisions_index', 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 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.fr_locale = Locale.objects.create(language_code="fr")
self.root_page_fr = self.root_page.copy_for_translation(self.fr_locale)
self.root_page_fr.title = "Bienvenue"
self.root_page_fr.save()
self.child_page_fr = self.child_page.copy_for_translation(
self.fr_locale)
self.child_page_fr.save()
switch_to_french_url = self.get_choose_page_url(
self.fr_locale, parent_page_id=self.child_page_fr.pk)
self.LOCALE_SELECTOR_HTML_FR = f'<a href="{switch_to_french_url}" aria-label="French" class="u-link is-live">'
self.login()
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):
# Find root page
self.root_page = Page.objects.get(id=2)
# Login
self.user = self.login()
# Create two moderator users for testing 'submitted' email
User = get_user_model()
self.moderator = User.objects.create_superuser('moderator',
'*****@*****.**',
'password')
self.moderator2 = User.objects.create_superuser(
'moderator2', '*****@*****.**', 'password')
# Create a submitter for testing 'rejected' and 'approved' emails
self.submitter = User.objects.create_user('submitter',
'*****@*****.**',
'password')
# User profiles for moderator2 and the submitter
self.moderator2_profile = UserProfile.get_for_user(self.moderator2)
self.submitter_profile = UserProfile.get_for_user(self.submitter)
# Create a page and submit it for moderation
self.child_page = SimplePage(
title="Hello world!",
slug='hello-world',
content="hello",
live=False,
)
self.root_page.add_child(instance=self.child_page)
# POST data to edit the page
self.post_data = {
'title': "I've been edited!",
'content': "Some content",
'slug': 'hello-world',
'action-submit': "Submit",
}
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 stream page (which has empty preview_modes, and so doesn't allow viewing draft)
self.stream_page = StreamPage(title="stream page",
body=[("text", "hello")])
self.root_page.add_child(instance=self.stream_page)
# create user with admin access (but not draft_view access)
user = self.create_user(username="******", password="******")
user.user_permissions.add(
Permission.objects.get(content_type__app_label="wagtailadmin",
codename="access_admin"))
def test_go_live_when_newer_revision_exists(self):
page = SimplePage(
title="Hello world!",
slug="hello-world",
live=False,
has_unpublished_changes=True,
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))
page.title = "Goodbye world!"
page.save_revision(submitted_for_moderation=False)
management.call_command('publish_scheduled_pages')
p = Page.objects.get(slug='hello-world')
self.assertTrue(p.live)
self.assertTrue(p.has_unpublished_changes)
self.assertEqual(p.title, "Hello world!")
def setUp(self):
self.page = SimplePage(
title="Hello world!",
slug="hello-world",
content="hello",
live=False,
expire_at=timezone.now() - timedelta(days=1),
)
Page.objects.get(id=2).add_child(instance=self.page)
# Create empty revisions, which should not be converted to log entries
for i in range(3):
self.page.save_revision()
# Add another revision with a content change
self.page.title = "Hello world!!"
revision = self.page.save_revision()
revision.publish()
# clean up log entries
PageLogEntry.objects.all().delete()
def test_cache_clears_when_site_root_moves(self):
"""
This tests for an issue where if a site root page was moved, all
the page urls in that site would change to None.
The issue was caused by the 'wagtail_site_root_paths' cache
variable not being cleared when a site root page was moved. Which
left all the child pages thinking that they are no longer in the
site and return None as their url.
Fix: d6cce69a397d08d5ee81a8cbc1977ab2c9db2682
Discussion: https://github.com/wagtail/wagtail/issues/7
"""
# Get homepage, root page and site
root_page = Page.objects.get(id=1)
homepage = Page.objects.get(url_path="/home/")
default_site = Site.objects.get(is_default_site=True)
# Create a new homepage under current homepage
new_homepage = SimplePage(title="New Homepage",
slug="new-homepage",
content="hello")
homepage.add_child(instance=new_homepage)
# Set new homepage as the site root page
default_site.root_page = new_homepage
default_site.save()
# Warm up the cache by getting the url
_ = homepage.url # noqa
# Move new homepage to root
new_homepage.move(root_page, pos="last-child")
# Get fresh instance of new_homepage
new_homepage = Page.objects.get(id=new_homepage.id)
# Check url
self.assertEqual(new_homepage.url, "/")
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 setUp(self):
# Find root page
self.root_page = Page.objects.get(id=2)
# Login
self.user = self.login()
# Create two moderator users for testing 'submitted' email
self.moderator = self.create_superuser("moderator",
"*****@*****.**",
"password")
self.moderator2 = self.create_superuser("moderator2",
"*****@*****.**",
"password")
# Create a submitter for testing 'rejected' and 'approved' emails
self.submitter = self.create_user("submitter", "*****@*****.**",
"password")
# User profiles for moderator2 and the submitter
self.moderator2_profile = UserProfile.get_for_user(self.moderator2)
self.submitter_profile = UserProfile.get_for_user(self.submitter)
# Create a page and submit it for moderation
self.child_page = SimplePage(
title="Hello world!",
slug="hello-world",
content="hello",
live=False,
)
self.root_page.add_child(instance=self.child_page)
# POST data to edit the page
self.post_data = {
"title": "I've been edited!",
"content": "Some content",
"slug": "hello-world",
"action-submit": "Submit",
}
