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_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_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_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 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)