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)
def test_allowed_parent_page_types(self):
# SimplePage does not define any restrictions on parent page types
# SimplePage is a valid parent page of SimplePage
self.assertIn(ContentType.objects.get_for_model(SimplePage), SimplePage.allowed_parent_page_types())
# BusinessChild cannot be a parent of anything
self.assertNotIn(ContentType.objects.get_for_model(BusinessChild), SimplePage.allowed_parent_page_types())
# StandardIndex does not allow anything as a parent
self.assertNotIn(ContentType.objects.get_for_model(SimplePage), StandardIndex.allowed_parent_page_types())
self.assertNotIn(ContentType.objects.get_for_model(StandardIndex), StandardIndex.allowed_parent_page_types())
# BusinessSubIndex only allows BusinessIndex as a parent
self.assertNotIn(ContentType.objects.get_for_model(SimplePage), BusinessSubIndex.allowed_parent_page_types())
self.assertIn(ContentType.objects.get_for_model(BusinessIndex), BusinessSubIndex.allowed_parent_page_types())
def test_allowed_parent_page_models(self):
# SimplePage does not define any restrictions on parent page types
# SimplePage is a valid parent page of SimplePage
self.assertIn(SimplePage, SimplePage.allowed_parent_page_models())
# BusinessChild cannot be a parent of anything
self.assertNotIn(BusinessChild, SimplePage.allowed_parent_page_models())
# BusinessNowherePage does not allow anything as a parent
self.assertNotIn(SimplePage, BusinessNowherePage.allowed_parent_page_models())
self.assertNotIn(StandardIndex, BusinessNowherePage.allowed_parent_page_models())
# BusinessSubIndex only allows BusinessIndex as a parent
self.assertNotIn(SimplePage, BusinessSubIndex.allowed_parent_page_models())
self.assertIn(BusinessIndex, BusinessSubIndex.allowed_parent_page_models())
def setUp(self):
# Create a submitter
submitter = get_user_model().objects.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 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,
))
self.private_groups_page = self.homepage.add_child(instance=SimplePage(
title="Private groups page",
content="hello",
live=True,
))
restriction = PageViewRestriction.objects.create(
page=self.private_groups_page, restriction_type='groups')
self.group = Group.objects.create(name='Private page group')
self.group2 = Group.objects.create(name='Private page group2')
restriction.groups.add(self.group)
restriction.groups.add(self.group2)
self.private_groups_child_page = self.private_groups_page.add_child(
instance=SimplePage(
title="Private groups child page",
content="hello",
live=True,
))
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 setUp(self):
self.root_page = Page.objects.get(id=1)
# For simple tests
self.home_page = self.root_page.add_child(
instance=SimplePage(title="Homepage", slug="home"))
self.about_page = self.home_page.add_child(
instance=SimplePage(title="About us", slug="about"))
self.contact_page = self.home_page.add_child(
instance=SimplePage(title="Contact", slug="contact"))
# For custom tests
self.event_index = self.root_page.add_child(
instance=EventIndex(title="Events", slug="events"))
for i in range(20):
self.event_index.add_child(instance=EventPage(
title="Event " + str(i), slug="event" + str(i)))
def test_allowed_subpage_models(self):
# SimplePage does not define any restrictions on subpage types
# SimplePage is a valid subpage of SimplePage
self.assertIn(SimplePage, SimplePage.allowed_subpage_models())
# BusinessIndex is a valid subpage of SimplePage
self.assertIn(BusinessIndex, SimplePage.allowed_subpage_models())
# BusinessSubIndex is not valid, because it explicitly omits SimplePage from parent_page_types
self.assertNotIn(BusinessSubIndex, SimplePage.allowed_subpage_models())
# BusinessChild has an empty subpage_types list, so does not allow anything
self.assertNotIn(SimplePage, BusinessChild.allowed_subpage_models())
self.assertNotIn(BusinessIndex, BusinessChild.allowed_subpage_models())
self.assertNotIn(BusinessSubIndex, BusinessChild.allowed_subpage_models())
# BusinessSubIndex only allows BusinessChild as subpage type
self.assertNotIn(SimplePage, BusinessSubIndex.allowed_subpage_models())
self.assertIn(BusinessChild, BusinessSubIndex.allowed_subpage_models())
def test_allowed_subpage_models(self):
# SimplePage does not define any restrictions on subpage types
# SimplePage is a valid subpage of SimplePage
self.assertIn(SimplePage, SimplePage.allowed_subpage_models())
# BusinessIndex is a valid subpage of SimplePage
self.assertIn(BusinessIndex, SimplePage.allowed_subpage_models())
# BusinessSubIndex is not valid, because it explicitly omits SimplePage from parent_page_types
self.assertNotIn(BusinessSubIndex, SimplePage.allowed_subpage_models())
# BusinessChild has an empty subpage_types list, so does not allow anything
self.assertNotIn(SimplePage, BusinessChild.allowed_subpage_models())
self.assertNotIn(BusinessIndex, BusinessChild.allowed_subpage_models())
self.assertNotIn(BusinessSubIndex, BusinessChild.allowed_subpage_models())
# BusinessSubIndex only allows BusinessChild as subpage type
self.assertNotIn(SimplePage, BusinessSubIndex.allowed_subpage_models())
self.assertIn(BusinessChild, BusinessSubIndex.allowed_subpage_models())
def test_slug_can_duplicate_other_sections(self):
homepage = Page.objects.get(url_path='/home/')
# the Events section has a page with slug='christmas', but we still allow
# it as a slug elsewhere
christmas_page = SimplePage(title="Christmas", slug='christmas', content="hello")
homepage.add_child(instance=christmas_page)
self.assertTrue(Page.objects.filter(id=christmas_page.id).exists())
def test_links_get_expanded(self):
page = SimplePage(title='foo', slug='foo', content='content')
default_site = Site.objects.get(is_default_site=True)
default_site.root_page.add_child(instance=page)
html = '<a linktype="page" id="{}">Link</a>'.format(page.pk)
block = ReusableTextChooserBlock(ReusableText)
self.assertIn('<a href="/foo/">', block.render({'text': html}))
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 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 setup_pagination_test_data(self):
# Create lots of pages
for i in range(100):
new_page = SimplePage(
title="foobarbaz",
slug="foobarbaz",
)
self.root_page.add_child(instance=new_page)
def create_draft_page(site, title):
page = SimplePage(title=title,
slug=slugify(title),
content='content',
live=False)
site.root_page.add_child(instance=page)
return page
class TestConvertAlias(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 alias page
self.alias_page = self.child_page.create_alias(update_slug='alias-page')
# Login
self.user = self.login()
def test_convert_alias(self):
response = self.client.get(reverse('wagtailadmin_pages:convert_alias', args=[self.alias_page.id]))
self.assertEqual(response.status_code, 200)
def test_convert_alias_not_alias(self):
response = self.client.get(reverse('wagtailadmin_pages:convert_alias', args=[self.child_page.id]))
self.assertEqual(response.status_code, 404)
def test_convert_alias_bad_permission(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()
response = self.client.get(reverse('wagtailadmin_pages:convert_alias', args=[self.alias_page.id]))
# Check that the user received a permission denied response
self.assertRedirects(response, '/admin/')
def test_post_convert_alias(self):
response = self.client.post(reverse('wagtailadmin_pages:convert_alias', args=[self.alias_page.id]))
# User should be redirected to the edit view of the converted page
self.assertRedirects(response, reverse('wagtailadmin_pages:edit', args=[self.alias_page.id]))
# Check the page was converted
self.alias_page.refresh_from_db()
self.assertIsNone(self.alias_page.alias_of)
# Check that a revision was created
revision = self.alias_page.revisions.get()
self.assertEqual(revision.user, self.user)
self.assertEqual(self.alias_page.live_revision, revision)
# Check audit log
log = PageLogEntry.objects.get(action='wagtail.convert_alias')
self.assertFalse(log.content_changed)
self.assertEqual(json.loads(log.data_json), {"page": {"id": self.alias_page.id, "title": self.alias_page.get_admin_display_title()}})
self.assertEqual(log.page, self.alias_page.page_ptr)
self.assertEqual(log.revision, revision)
self.assertEqual(log.user, self.user)
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_page_move(self):
section = self.root_page.add_child(
instance=SimplePage(title="About us", slug="about", content="hello")
)
user = get_user_model().objects.first()
section.move(self.home_page, 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 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 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_can_create_at(self):
# Pages are not `is_creatable`, and should not be creatable
self.assertFalse(Page.can_create_at(Page()))
# SimplePage can be created under a simple page
self.assertTrue(SimplePage.can_create_at(SimplePage()))
# StandardIndex can be created under a Page, but not a SimplePage
self.assertTrue(StandardIndex.can_create_at(Page()))
self.assertFalse(StandardIndex.can_create_at(SimplePage()))
# The Business pages are quite restrictive in their structure
self.assertTrue(BusinessSubIndex.can_create_at(BusinessIndex()))
self.assertTrue(BusinessChild.can_create_at(BusinessIndex()))
self.assertTrue(BusinessChild.can_create_at(BusinessSubIndex()))
self.assertFalse(BusinessChild.can_create_at(SimplePage()))
self.assertFalse(BusinessSubIndex.can_create_at(SimplePage()))
def test_assert_can_create_subpage_rules(self):
simple_page = SimplePage(title='Simple Page', slug='simple')
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 setUp(self):
self.root_page = Page.objects.get(id=2)
# Add child page
self.child_page = SimplePage(
title="foobarbaz",
slug="foobarbaz",
)
self.root_page.add_child(instance=self.child_page)
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 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_expired_pages_are_dropped_from_mod_queue(self):
page = SimplePage(
title="Hello world!",
slug="hello-world",
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 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):
self.user = self.create_superuser(username='******',
email='*****@*****.**',
password='******')
self.page = Page.objects.get(pk=1)
self.simple_page = self.page.add_child(
instance=SimplePage(title="Simple page",
slug="simple",
content="Hello",
owner=self.user))
def setUp(self):
self.home_page = Page.objects.get(id=2)
self.child_page = self.home_page.add_child(
instance=SimplePage(title="Hello world!",
slug='hello-world',
content="hello",
live=True,
last_published_at=datetime.datetime(
2017, 1, 1, 12, 0, 0, tzinfo=pytz.utc),
latest_revision_created_at=datetime.datetime(
2017, 2, 1, 12, 0, 0, tzinfo=pytz.utc)))
self.unpublished_child_page = self.home_page.add_child(
instance=SimplePage(
title="Unpublished",
slug='unpublished',
content="hello",
live=False,
))
self.protected_child_page = self.home_page.add_child(
instance=SimplePage(
title="Protected",
slug='protected',
content="hello",
live=True,
))
PageViewRestriction.objects.create(page=self.protected_child_page,
password='******')
self.page_with_no_last_publish_date = self.home_page.add_child(
instance=SimplePage(title="I have no last publish date :-(",
slug='no-last-publish-date',
content="hello",
live=True,
latest_revision_created_at=datetime.datetime(
2017, 2, 1, 12, 0, 0, tzinfo=pytz.utc)))
self.site = Site.objects.get(is_default_site=True)
# Clear the cache to that runs are deterministic regarding the sql count
ContentType.objects.clear_cache()
class TestServeLatestDraftPage(TestCase):
def setUp(self):
self.default_site = Site.objects.get(is_default_site=True)
self.page = SimplePage(title='live', slug='test', content='test')
self.default_site.root_page.add_child(instance=self.page)
self.page.title = 'draft'
self.page.save_revision()
@override_settings(SERVE_LATEST_DRAFT_PAGES=[])
def test_not_serving_draft_serves_published_revision(self):
response = self.client.get('/test/')
self.assertContains(response, 'live')
self.assertIsNone(response.get('Serving-Wagtail-Draft'))
def test_serving_draft_serves_latest_revision_and_adds_header(self):
with override_settings(SERVE_LATEST_DRAFT_PAGES=[self.page.pk]):
response = self.client.get('/test/')
self.assertContains(response, 'draft')
self.assertEqual(response['Serving-Wagtail-Draft'], '1')
class TestCreateLogEntriesFromRevisionsCommand(TestCase):
fixtures = ["test.json"]
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_log_entries_created_from_revisions(self):
management.call_command("create_log_entries_from_revisions")
# Should not create entries for empty revisions.
self.assertListEqual(
list(PageLogEntry.objects.values_list("action", flat=True)),
["wagtail.publish", "wagtail.edit", "wagtail.create"],
)
def test_command_doesnt_crash_for_revisions_without_page_model(self):
with mock.patch(
"wagtail.core.models.ContentType.model_class",
return_value=None,
):
management.call_command("create_log_entries_from_revisions")
self.assertEqual(PageLogEntry.objects.count(), 0)
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_page_create(self):
self.assertEqual(PageLogEntry.objects.count(), 0) # homepage
page = self.home_page.add_child(instance=SimplePage(
title="Hello", slug="my-page", content="world"))
self.assertEqual(PageLogEntry.objects.count(), 1)
log_entry = PageLogEntry.objects.order_by('pk').last()
self.assertEqual(log_entry.action, 'wagtail.create')
self.assertEqual(log_entry.page_id, page.id)
self.assertEqual(log_entry.content_type, page.content_type)
self.assertEqual(log_entry.label, page.get_admin_display_title())
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 test_can_create(self):
"""
Check that basic page creation works
"""
homepage = Page.objects.get(url_path='/home/')
hello_page = SimplePage(title="Hello world", slug='hello-world', content="hello")
homepage.add_child(instance=hello_page)
# check that hello_page exists in the db
retrieved_page = Page.objects.get(id=hello_page.id)
self.assertEqual(retrieved_page.title, "Hello world")
def check_page_renders_as_relative_link(self):
page = SimplePage(title='title', slug='slug', content='content')
self.default_site.root_page.add_child(instance=page)
self.assertEqual(
RelativePageLinkHandler.expand_db_attributes(
attrs={'id': page.pk},
for_editor=False
),
'<a href="/slug/">',
)
def test_allowed_parent_page_types(self):
# SimplePage does not define any restrictions on parent page types
# SimplePage is a valid parent page of SimplePage
self.assertIn(ContentType.objects.get_for_model(SimplePage),
SimplePage.allowed_parent_page_types())
# BusinessChild cannot be a parent of anything
self.assertNotIn(ContentType.objects.get_for_model(BusinessChild),
SimplePage.allowed_parent_page_types())
# StandardIndex does not allow anything as a parent
self.assertNotIn(ContentType.objects.get_for_model(SimplePage),
StandardIndex.allowed_parent_page_types())
self.assertNotIn(ContentType.objects.get_for_model(StandardIndex),
StandardIndex.allowed_parent_page_types())
# BusinessSubIndex only allows BusinessIndex as a parent
self.assertNotIn(ContentType.objects.get_for_model(SimplePage),
BusinessSubIndex.allowed_parent_page_types())
self.assertIn(ContentType.objects.get_for_model(BusinessIndex),
BusinessSubIndex.allowed_parent_page_types())
def test_future_go_live_page_will_not_be_published(self):
page = SimplePage(
title="Hello world!",
slug="hello-world",
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())
class TestRevisionPreviewView(TestCase, WagtailTestUtils):
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 get_url(self):
return reverse(
'wagtailrollbacks:preview_page_version',
args=(self.child_page.get_latest_revision().id,)
)
def get_get_permission_denied(self):
self.client.logout()
with self.assertRaises(PermissionDenied):
self.client.get(self.get_url())
def test_get(self):
# Generate the response.
response = self.client.get(self.get_url())
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'tests/simple_page.html')
def test_allowed_parent_page_types(self):
"""
Same assertions as for test_allowed_parent_page_models -
allowed_parent_page_types should mirror allowed_parent_page_models
with ContentType objects rather than model classes
"""
with self.ignore_deprecation_warnings():
# SimplePage does not define any restrictions on parent page types
# SimplePage is a valid parent page of SimplePage
self.assertIn(get_ct(SimplePage), SimplePage.allowed_parent_page_types())
# BusinessChild cannot be a parent of anything
self.assertNotIn(get_ct(BusinessChild), SimplePage.allowed_parent_page_types())
# BusinessNowherePage does not allow anything as a parent
self.assertNotIn(get_ct(SimplePage), BusinessNowherePage.allowed_parent_page_types())
self.assertNotIn(get_ct(StandardIndex), BusinessNowherePage.allowed_parent_page_types())
# BusinessSubIndex only allows BusinessIndex as a parent
self.assertNotIn(get_ct(SimplePage), BusinessSubIndex.allowed_parent_page_types())
self.assertIn(get_ct(BusinessIndex), BusinessSubIndex.allowed_parent_page_types())
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_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_allowed_subpage_types(self):
"""
Same assertions as for test_allowed_subpage_models -
allowed_subpage_types should mirror allowed_subpage_models with ContentType
objects rather than model classes
"""
with self.ignore_deprecation_warnings():
# SimplePage does not define any restrictions on subpage types
# SimplePage is a valid subpage of SimplePage
self.assertIn(get_ct(SimplePage), SimplePage.allowed_subpage_types())
# BusinessIndex is a valid subpage of SimplePage
self.assertIn(get_ct(BusinessIndex), SimplePage.allowed_subpage_types())
# BusinessSubIndex is not valid, because it explicitly omits SimplePage from parent_page_types
self.assertNotIn(get_ct(BusinessSubIndex), SimplePage.allowed_subpage_types())
# BusinessChild has an empty subpage_types list, so does not allow anything
self.assertNotIn(get_ct(SimplePage), BusinessChild.allowed_subpage_types())
self.assertNotIn(get_ct(BusinessIndex), BusinessChild.allowed_subpage_types())
self.assertNotIn(get_ct(BusinessSubIndex), BusinessChild.allowed_subpage_types())
# BusinessSubIndex only allows BusinessChild as subpage type
self.assertNotIn(get_ct(SimplePage), BusinessSubIndex.allowed_subpage_types())
self.assertIn(get_ct(BusinessChild), BusinessSubIndex.allowed_subpage_types())
def test_can_exist_under(self):
self.assertTrue(SimplePage.can_exist_under(SimplePage()))
# StandardIndex should only be allowed under a Page
self.assertTrue(StandardIndex.can_exist_under(Page()))
self.assertFalse(StandardIndex.can_exist_under(SimplePage()))
# The Business pages are quite restrictive in their structure
self.assertTrue(BusinessSubIndex.can_exist_under(BusinessIndex()))
self.assertTrue(BusinessChild.can_exist_under(BusinessIndex()))
self.assertTrue(BusinessChild.can_exist_under(BusinessSubIndex()))
self.assertFalse(BusinessSubIndex.can_exist_under(SimplePage()))
self.assertFalse(BusinessSubIndex.can_exist_under(BusinessSubIndex()))
self.assertFalse(BusinessChild.can_exist_under(SimplePage()))
def test_can_create_at(self):
# Pages are not `is_creatable`, and should not be creatable
self.assertFalse(Page.can_create_at(Page()))
# SimplePage can be created under a simple page
self.assertTrue(SimplePage.can_create_at(SimplePage()))
# StandardIndex can be created under a Page, but not a SimplePage
self.assertTrue(StandardIndex.can_create_at(Page()))
self.assertFalse(StandardIndex.can_create_at(SimplePage()))
# The Business pages are quite restrictive in their structure
self.assertTrue(BusinessSubIndex.can_create_at(BusinessIndex()))
self.assertTrue(BusinessChild.can_create_at(BusinessIndex()))
self.assertTrue(BusinessChild.can_create_at(BusinessSubIndex()))
self.assertFalse(BusinessChild.can_create_at(SimplePage()))
self.assertFalse(BusinessSubIndex.can_create_at(SimplePage()))
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 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 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!")
class TestConfirmPageReversionView(TestCase, WagtailTestUtils):
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 get_url(self):
return reverse(
'wagtailrollbacks:confirm_page_reversion',
args=(self.child_page.get_latest_revision().id,)
)
def get_get_permission_denied(self):
self.client.logout()
with self.assertRaises(PermissionDenied):
self.client.get(self.get_url())
def test_page_is_locked(self):
self.child_page.locked = True
Page.objects.filter(pk=self.child_page.pk).update(locked=True)
response = self.client.get(self.get_url())
self.assertRedirects(
response,
reverse('wagtailadmin_pages:edit', args=(self.child_page.id,))
)
def test_get(self):
response = self.client.get(self.get_url())
self.assertTemplateUsed(
response,
'wagtailrollbacks/pages/confirm_reversion.html'
)
def test_post_draft(self):
response = self.client.post(self.get_url(), {'fake': 'data'})
self.assertRedirects(
response,
reverse('wagtailadmin_explore', args=(self.child_page.get_parent().id,))
)
def test_post_publish(self):
post_data = {'action-publish': True}
response = self.client.post(self.get_url(), post_data)
self.assertRedirects(
response,
reverse('wagtailadmin_explore', args=(self.child_page.get_parent().id,))
)
def test_post_submit(self):
post_data = {'action-submit': True}
response = self.client.post(self.get_url(), post_data)
self.assertRedirects(
response,
reverse('wagtailadmin_explore', args=(self.child_page.get_parent().id,))
)
class TestPageRevisionsView(TestCase, WagtailTestUtils):
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 get_get_permission_denied(self):
self.client.logout()
with self.assertRaises(PermissionDenied):
self.client.get(self.get_url())
def get(self, params=None):
if not params:
params = {}
return self.client.get(
reverse('wagtailrollbacks:page_revisions', args=(self.child_page.id,)),
params
)
def test_pagination(self):
# Generate the response.
page_num = 2
response = self.get({'p': 2})
# Check assertions.
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(
response,
'wagtailrollbacks/edit_handlers/revisions.html'
)
self.assertEqual(response.context['revisions'].number, page_num)
self.assertContains(response, 'Page {0} of '.format(page_num))
def test_pagination_invalid(self):
# Generate the response.
response = self.get({'p': 'fake'})
# Check assertions.
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(
response,
'wagtailrollbacks/edit_handlers/revisions.html'
)
self.assertEqual(response.context['revisions'].number, 1)
def test_pagination_out_of_range(self):
# Generate the response.
response = self.get({'p': 99999})
# Check assertions.
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(
response,
'wagtailrollbacks/edit_handlers/revisions.html'
)
self.assertEqual(
response.context['revisions'].number,
response.context['revisions'].paginator.num_pages
)
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')
self.assertInHTML("foobarbaz (simple page)", response.json().get('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
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_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)
def setUp(self):
self.default_site = Site.objects.get(is_default_site=True)
self.page = SimplePage(title='live', slug='test', content='test')
self.default_site.root_page.add_child(instance=self.page)
self.page.title = 'draft'
self.page.save_revision()
class TestModerationList(TestCase, WagtailTestUtils):
"""Test moderation list rendered by `wagtailadmin_home` view"""
def setUp(self):
# Create a submitter
submitter = get_user_model().objects.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 login_as_moderator_without_edit(self):
# Create moderators group without edit permissions
moderators_group = Group.objects.create(name='Moderators without edit')
admin_permission = Permission.objects.get(
content_type__app_label='wagtailadmin',
codename='access_admin'
)
moderators_group.permissions.add(admin_permission)
# Create group permissions
GroupPagePermission.objects.create(
group=moderators_group,
page=self.root_page,
permission_type='publish',
)
# Create a moderator without edit permissions
moderator = get_user_model().objects.create_user(
username='******',
email='*****@*****.**',
password='******'
)
moderator.groups.add(moderators_group)
self.login(moderator)
def get(self):
return self.client.get(reverse('wagtailadmin_home'))
def test_edit_page(self):
# Login as moderator
self.login()
response = self.get()
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'wagtailadmin/home.html')
# Check response
self.assertContains(response, self.edit_page_url, count=2)
def test_preview_for_moderation(self):
# Login as moderator without edit permissions
self.login_as_moderator_without_edit()
response = self.get()
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'wagtailadmin/home.html')
# Check response
self.assertContains(response, self.preview_page_url, count=2)
self.assertNotContains(response, self.edit_page_url)
