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", 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.assertTrue(p.live) 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_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", 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.assertTrue(p.live) 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_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 TestPageEdit(TestCase): def setUp(self): # Find root page self.root_page = Page.objects.get(id=2) # Add child page self.child_page = SimplePage() self.child_page.title = "Hello world!" self.child_page.slug = "hello-world" self.child_page.live = True self.root_page.add_child(self.child_page) self.child_page.save_revision() # Add event page (to test edit handlers) self.event_page = EventPage() self.event_page.title = "Event page" self.event_page.slug = "event-page" self.root_page.add_child(self.event_page) # Login login(self.client) def test_edit_page(self): # Tests that the edit page loads response = self.client.get(reverse("wagtailadmin_pages_edit", args=(self.event_page.id,))) self.assertEqual(response.status_code, 200) def test_edit_post(self): # Tests simple editing post_data = {"title": "I've been edited!", "content": "Some content", "slug": "hello-world"} response = self.client.post(reverse("wagtailadmin_pages_edit", args=(self.child_page.id,)), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) # The page should have "has_unpublished_changes" flag set child_page_new = SimplePage.objects.get(id=self.child_page.id) self.assertTrue(child_page_new.has_unpublished_changes) def test_edit_post_publish(self): # Tests publish from edit page post_data = { "title": "I've been edited!", "content": "Some content", "slug": "hello-world", "action-publish": "Publish", } response = self.client.post(reverse("wagtailadmin_pages_edit", args=(self.child_page.id,)), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) # Check that the page was edited child_page_new = SimplePage.objects.get(id=self.child_page.id) self.assertEqual(child_page_new.title, post_data["title"]) # The page shouldn't have "has_unpublished_changes" flag set self.assertFalse(child_page_new.has_unpublished_changes)
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 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())
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 test_go_live_when_newer_revision_exists(self): page = SimplePage( title="Hello world!", slug="hello-world", live=False, has_unpublished_changes=True, go_live_at=timezone.now() - timedelta(days=1), ) self.root_page.add_child(instance=page) page.save_revision(approved_go_live_at=timezone.now() - timedelta(days=1)) page.title = "Goodbye world!" page.save_revision(submitted_for_moderation=False) management.call_command('publish_scheduled_pages') p = Page.objects.get(slug='hello-world') self.assertTrue(p.live) self.assertTrue(p.has_unpublished_changes) self.assertEqual(p.title, "Hello world!")
def 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 TestApproveRejectModeration(TestCase): def setUp(self): self.submitter = User.objects.create_superuser( username='******', email='*****@*****.**', password='******', ) self.user = login(self.client) # Create a page and submit it for moderation root_page = Page.objects.get(id=2) self.page = SimplePage( title="Hello world!", slug='hello-world', live=False, ) root_page.add_child(instance=self.page) self.page.save_revision(user=self.submitter, submitted_for_moderation=True) self.revision = self.page.get_latest_revision() def test_approve_moderation_view(self): """ This posts to the approve moderation view and checks that the page was approved """ # Post response = self.client.post(reverse('wagtailadmin_pages_approve_moderation', args=(self.revision.id, )), { 'foo': "Must post something or the view won't see this as a POST request", }) # Check that the user was redirected self.assertEqual(response.status_code, 302) # Page must be live self.assertTrue(Page.objects.get(id=self.page.id).live) # Submitter must recieve an approved email self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, ['*****@*****.**']) self.assertEqual(mail.outbox[0].subject, 'The page "Hello world!" has been approved') def test_approve_moderation_view_bad_revision_id(self): """ This tests that the approve moderation view handles invalid revision ids correctly """ # Post response = self.client.post(reverse('wagtailadmin_pages_approve_moderation', args=(12345, )), { 'foo': "Must post something or the view won't see this as a POST request", }) # Check that the user recieved a 404 response self.assertEqual(response.status_code, 404) def test_approve_moderation_view_bad_permissions(self): """ This tests that the approve moderation view doesn't allow users without moderation permissions """ # 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() # Post response = self.client.post(reverse('wagtailadmin_pages_approve_moderation', args=(self.revision.id, )), { 'foo': "Must post something or the view won't see this as a POST request", }) # Check that the user recieved a 403 response self.assertEqual(response.status_code, 403) def test_reject_moderation_view(self): """ This posts to the reject moderation view and checks that the page was rejected """ # Post response = self.client.post(reverse('wagtailadmin_pages_reject_moderation', args=(self.revision.id, )), { 'foo': "Must post something or the view won't see this as a POST request", }) # Check that the user was redirected self.assertEqual(response.status_code, 302) # Page must not be live self.assertFalse(Page.objects.get(id=self.page.id).live) # Revision must no longer be submitted for moderation self.assertFalse(PageRevision.objects.get(id=self.revision.id).submitted_for_moderation) # Submitter must recieve a rejected email self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, ['*****@*****.**']) self.assertEqual(mail.outbox[0].subject, 'The page "Hello world!" has been rejected') def test_reject_moderation_view_bad_revision_id(self): """ This tests that the reject moderation view handles invalid revision ids correctly """ # Post response = self.client.post(reverse('wagtailadmin_pages_reject_moderation', args=(12345, )), { 'foo': "Must post something or the view won't see this as a POST request", }) # Check that the user recieved a 404 response self.assertEqual(response.status_code, 404) def test_reject_moderation_view_bad_permissions(self): """ This tests that the reject moderation view doesn't allow users without moderation permissions """ # 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() # Post response = self.client.post(reverse('wagtailadmin_pages_reject_moderation', args=(self.revision.id, )), { 'foo': "Must post something or the view won't see this as a POST request", }) # Check that the user recieved a 403 response self.assertEqual(response.status_code, 403) def test_preview_for_moderation(self): response = self.client.get(reverse('wagtailadmin_pages_preview_for_moderation', args=(self.revision.id, ))) # Check response self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'tests/simple_page.html') self.assertContains(response, "Hello world!")
class TestPageEdit(TestCase): def setUp(self): # Find root page self.root_page = Page.objects.get(id=2) # Add child page self.child_page = SimplePage() self.child_page.title = "Hello world!" self.child_page.slug = "hello-world" self.child_page.live = True self.root_page.add_child(instance=self.child_page) self.child_page.save_revision() # Add event page (to test edit handlers) self.event_page = EventPage() self.event_page.title = "Event page" self.event_page.slug = "event-page" self.root_page.add_child(instance=self.event_page) # Login self.user = login(self.client) def test_page_edit(self): # Tests that the edit page loads response = self.client.get(reverse('wagtailadmin_pages_edit', args=(self.event_page.id, ))) self.assertEqual(response.status_code, 200) def test_page_edit_bad_permissions(self): # Remove privileges from user self.user.is_superuser = False self.user.user_permissions.add( Permission.objects.get(content_type__app_label='wagtailadmin', codename='access_admin') ) self.user.save() # Get edit page response = self.client.get(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, ))) # Check that the user recieved a 403 response self.assertEqual(response.status_code, 403) def test_page_edit_post(self): # Tests simple editing post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) # The page should have "has_unpublished_changes" flag set child_page_new = SimplePage.objects.get(id=self.child_page.id) self.assertTrue(child_page_new.has_unpublished_changes) def test_page_edit_post_publish(self): # Tests publish from edit page post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-publish': "Publish", } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) # Check that the page was edited child_page_new = SimplePage.objects.get(id=self.child_page.id) self.assertEqual(child_page_new.title, post_data['title']) # The page shouldn't have "has_unpublished_changes" flag set self.assertFalse(child_page_new.has_unpublished_changes) def test_page_edit_post_submit(self): # Create a moderator user for testing email moderator = User.objects.create_superuser('moderator', '*****@*****.**', 'password') # Tests submitting from edit page post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-submit': "Submit", } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) # The page should have "has_unpublished_changes" flag set child_page_new = SimplePage.objects.get(id=self.child_page.id) self.assertTrue(child_page_new.has_unpublished_changes) # The latest revision for the page should now be in moderation self.assertTrue(child_page_new.get_latest_revision().submitted_for_moderation) # Check that the moderator got an email self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, ['*****@*****.**']) self.assertEqual(mail.outbox[0].subject, 'The page "Hello world!" has been submitted for moderation') # Note: should this be "I've been edited!"? def test_preview_on_edit(self): post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-submit': "Submit", } response = self.client.post(reverse('wagtailadmin_pages_preview_on_edit', args=(self.child_page.id, )), post_data) # Check the response self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'tests/simple_page.html') self.assertContains(response, "I've been edited!")
class TestApproveRejectModeration(TestCase): def setUp(self): self.submitter = User.objects.create_superuser( username='******', email='*****@*****.**', password='******', ) self.user = login(self.client) # Create a page and submit it for moderation root_page = Page.objects.get(id=2) self.page = SimplePage( title="Hello world!", slug='hello-world', live=False, ) root_page.add_child(instance=self.page) self.page.save_revision(user=self.submitter, submitted_for_moderation=True) self.revision = self.page.get_latest_revision() def test_approve_moderation_view(self): """ This posts to the approve moderation view and checks that the page was approved """ # Post response = self.client.post( reverse('wagtailadmin_pages_approve_moderation', args=(self.revision.id, )), { 'foo': "Must post something or the view won't see this as a POST request", }) # Check that the user was redirected self.assertEqual(response.status_code, 302) # Page must be live self.assertTrue(Page.objects.get(id=self.page.id).live) # Submitter must recieve an approved email self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, ['*****@*****.**']) self.assertEqual(mail.outbox[0].subject, 'The page "Hello world!" has been approved') def test_approve_moderation_view_bad_revision_id(self): """ This tests that the approve moderation view handles invalid revision ids correctly """ # Post response = self.client.post( reverse('wagtailadmin_pages_approve_moderation', args=(12345, )), { 'foo': "Must post something or the view won't see this as a POST request", }) # Check that the user recieved a 404 response self.assertEqual(response.status_code, 404) def test_approve_moderation_view_bad_permissions(self): """ This tests that the approve moderation view doesn't allow users without moderation permissions """ # 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() # Post response = self.client.post( reverse('wagtailadmin_pages_approve_moderation', args=(self.revision.id, )), { 'foo': "Must post something or the view won't see this as a POST request", }) # Check that the user recieved a 403 response self.assertEqual(response.status_code, 403) def test_reject_moderation_view(self): """ This posts to the reject moderation view and checks that the page was rejected """ # Post response = self.client.post( reverse('wagtailadmin_pages_reject_moderation', args=(self.revision.id, )), { 'foo': "Must post something or the view won't see this as a POST request", }) # Check that the user was redirected self.assertEqual(response.status_code, 302) # Page must not be live self.assertFalse(Page.objects.get(id=self.page.id).live) # Revision must no longer be submitted for moderation self.assertFalse( PageRevision.objects.get( id=self.revision.id).submitted_for_moderation) # Submitter must recieve a rejected email self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, ['*****@*****.**']) self.assertEqual(mail.outbox[0].subject, 'The page "Hello world!" has been rejected') def test_reject_moderation_view_bad_revision_id(self): """ This tests that the reject moderation view handles invalid revision ids correctly """ # Post response = self.client.post( reverse('wagtailadmin_pages_reject_moderation', args=(12345, )), { 'foo': "Must post something or the view won't see this as a POST request", }) # Check that the user recieved a 404 response self.assertEqual(response.status_code, 404) def test_reject_moderation_view_bad_permissions(self): """ This tests that the reject moderation view doesn't allow users without moderation permissions """ # 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() # Post response = self.client.post( reverse('wagtailadmin_pages_reject_moderation', args=(self.revision.id, )), { 'foo': "Must post something or the view won't see this as a POST request", }) # Check that the user recieved a 403 response self.assertEqual(response.status_code, 403) def test_preview_for_moderation(self): response = self.client.get( reverse('wagtailadmin_pages_preview_for_moderation', args=(self.revision.id, ))) # Check response self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'tests/simple_page.html') self.assertContains(response, "Hello world!")
class TestPageEdit(TestCase): def setUp(self): # Find root page self.root_page = Page.objects.get(id=2) # Add child page self.child_page = SimplePage() self.child_page.title = "Hello world!" self.child_page.slug = "hello-world" self.child_page.live = True self.root_page.add_child(instance=self.child_page) self.child_page.save_revision() # Add event page (to test edit handlers) self.event_page = EventPage() self.event_page.title = "Event page" self.event_page.slug = "event-page" self.root_page.add_child(instance=self.event_page) # Login self.user = login(self.client) def test_page_edit(self): # Tests that the edit page loads response = self.client.get( reverse('wagtailadmin_pages_edit', args=(self.event_page.id, ))) self.assertEqual(response.status_code, 200) def test_page_edit_bad_permissions(self): # Remove privileges from user self.user.is_superuser = False self.user.user_permissions.add( Permission.objects.get(content_type__app_label='wagtailadmin', codename='access_admin')) self.user.save() # Get edit page response = self.client.get( reverse('wagtailadmin_pages_edit', args=(self.child_page.id, ))) # Check that the user recieved a 403 response self.assertEqual(response.status_code, 403) def test_page_edit_post(self): # Tests simple editing post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', } response = self.client.post( reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) # The page should have "has_unpublished_changes" flag set child_page_new = SimplePage.objects.get(id=self.child_page.id) self.assertTrue(child_page_new.has_unpublished_changes) def test_page_edit_post_publish(self): # Tests publish from edit page post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-publish': "Publish", } response = self.client.post( reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) # Check that the page was edited child_page_new = SimplePage.objects.get(id=self.child_page.id) self.assertEqual(child_page_new.title, post_data['title']) # The page shouldn't have "has_unpublished_changes" flag set self.assertFalse(child_page_new.has_unpublished_changes) def test_page_edit_post_submit(self): # Create a moderator user for testing email moderator = User.objects.create_superuser('moderator', '*****@*****.**', 'password') # Tests submitting from edit page post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-submit': "Submit", } response = self.client.post( reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) # The page should have "has_unpublished_changes" flag set child_page_new = SimplePage.objects.get(id=self.child_page.id) self.assertTrue(child_page_new.has_unpublished_changes) # The latest revision for the page should now be in moderation self.assertTrue( child_page_new.get_latest_revision().submitted_for_moderation) # Check that the moderator got an email self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, ['*****@*****.**']) self.assertEqual( mail.outbox[0].subject, 'The page "Hello world!" has been submitted for moderation' ) # Note: should this be "I've been edited!"? def test_preview_on_edit(self): post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-submit': "Submit", } response = self.client.post( reverse('wagtailadmin_pages_preview_on_edit', args=(self.child_page.id, )), post_data) # Check the response self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'tests/simple_page.html') self.assertContains(response, "I've been edited!")
class TestPageEdit(TestCase): def setUp(self): # Find root page self.root_page = Page.objects.get(id=2) # Add child page self.child_page = SimplePage() self.child_page.title = "Hello world!" self.child_page.slug = "hello-world" self.child_page.live = True self.root_page.add_child(self.child_page) self.child_page.save_revision() # Add event page (to test edit handlers) self.event_page = EventPage() self.event_page.title = "Event page" self.event_page.slug = "event-page" self.root_page.add_child(self.event_page) # Login login(self.client) def test_edit_page(self): # Tests that the edit page loads response = self.client.get(reverse('wagtailadmin_pages_edit', args=(self.event_page.id, ))) self.assertEqual(response.status_code, 200) def test_edit_post(self): # Tests simple editing post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) # The page should have "has_unpublished_changes" flag set child_page_new = SimplePage.objects.get(id=self.child_page.id) self.assertTrue(child_page_new.has_unpublished_changes) def test_edit_post_publish(self): # Tests publish from edit page post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-publish': "Publish", } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) # Check that the page was edited child_page_new = SimplePage.objects.get(id=self.child_page.id) self.assertEqual(child_page_new.title, post_data['title']) # The page shouldn't have "has_unpublished_changes" flag set self.assertFalse(child_page_new.has_unpublished_changes)
class TestPageEdit(TestCase, WagtailTestUtils): def setUp(self): # Find root page self.root_page = Page.objects.get(id=2) # Add child page self.child_page = SimplePage() self.child_page.title = "Hello world!" self.child_page.slug = "hello-world" self.child_page.live = True self.root_page.add_child(instance=self.child_page) self.child_page.save_revision() # Add event page (to test edit handlers) self.event_page = EventPage() self.event_page.title = "Event page" self.event_page.slug = "event-page" self.root_page.add_child(instance=self.event_page) # Login self.user = self.login() def test_page_edit(self): # Tests that the edit page loads response = self.client.get(reverse('wagtailadmin_pages_edit', args=(self.event_page.id, ))) self.assertEqual(response.status_code, 200) def test_page_edit_bad_permissions(self): # Remove privileges from user self.user.is_superuser = False self.user.user_permissions.add( Permission.objects.get(content_type__app_label='wagtailadmin', codename='access_admin') ) self.user.save() # Get edit page response = self.client.get(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, ))) # Check that the user recieved a 403 response self.assertEqual(response.status_code, 403) def test_page_edit_post(self): # Tests simple editing post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertRedirects(response, reverse('wagtailadmin_explore', args=(self.root_page.id, ))) # The page should have "has_unpublished_changes" flag set child_page_new = SimplePage.objects.get(id=self.child_page.id) self.assertTrue(child_page_new.has_unpublished_changes) def test_edit_post_scheduled(self): go_live_at = timezone.now() + timedelta(days=1) expire_at = timezone.now() + timedelta(days=2) post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'go_live_at': str(go_live_at).split('.')[0], 'expire_at': str(expire_at).split('.')[0], } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) child_page_new = SimplePage.objects.get(id=self.child_page.id) # The page will still be live self.assertTrue(child_page_new.live) # A revision with approved_go_live_at should not exist self.assertFalse(PageRevision.objects.filter(page=child_page_new).exclude(approved_go_live_at__isnull=True).exists()) # But a revision with go_live_at and expire_at in their content json *should* exist self.assertTrue(PageRevision.objects.filter(page=child_page_new, content_json__contains=str(go_live_at.date())).exists()) self.assertTrue(PageRevision.objects.filter(page=child_page_new, content_json__contains=str(expire_at.date())).exists()) def test_edit_scheduled_go_live_before_expiry(self): post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'go_live_at': str(timezone.now() + timedelta(days=2)).split('.')[0], 'expire_at': str(timezone.now() + timedelta(days=1)).split('.')[0], } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) self.assertEqual(response.status_code, 200) # Check that a form error was raised self.assertFormError(response, 'form', 'go_live_at', "Go live date/time must be before expiry date/time") self.assertFormError(response, 'form', 'expire_at', "Go live date/time must be before expiry date/time") def test_edit_scheduled_expire_in_the_past(self): post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'expire_at': str(timezone.now() + timedelta(days=-1)).split('.')[0], } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) self.assertEqual(response.status_code, 200) # Check that a form error was raised self.assertFormError(response, 'form', 'expire_at', "Expiry date/time must be in the future") def test_page_edit_post_publish(self): # Tests publish from edit page post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-publish': "Publish", } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertRedirects(response, reverse('wagtailadmin_explore', args=(self.root_page.id, ))) # Check that the page was edited child_page_new = SimplePage.objects.get(id=self.child_page.id) self.assertEqual(child_page_new.title, post_data['title']) # The page shouldn't have "has_unpublished_changes" flag set self.assertFalse(child_page_new.has_unpublished_changes) def test_edit_post_publish_scheduled(self): go_live_at = timezone.now() + timedelta(days=1) expire_at = timezone.now() + timedelta(days=2) post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-publish': "Publish", 'go_live_at': str(go_live_at).split('.')[0], 'expire_at': str(expire_at).split('.')[0], } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) child_page_new = SimplePage.objects.get(id=self.child_page.id) # The page should not be live anymore self.assertFalse(child_page_new.live) # Instead a revision with approved_go_live_at should now exist self.assertTrue(PageRevision.objects.filter(page=child_page_new).exclude(approved_go_live_at__isnull=True).exists()) def test_edit_post_publish_now_an_already_scheduled(self): # First let's publish a page with a go_live_at in the future go_live_at = timezone.now() + timedelta(days=1) expire_at = timezone.now() + timedelta(days=2) post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-publish': "Publish", 'go_live_at': str(go_live_at).split('.')[0], 'expire_at': str(expire_at).split('.')[0], } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) child_page_new = SimplePage.objects.get(id=self.child_page.id) # The page should not be live anymore self.assertFalse(child_page_new.live) # Instead a revision with approved_go_live_at should now exist self.assertTrue(PageRevision.objects.filter(page=child_page_new).exclude(approved_go_live_at__isnull=True).exists()) # Now, let's edit it and publish it right now go_live_at = timezone.now() post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-publish': "Publish", 'go_live_at': "", } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertEqual(response.status_code, 302) child_page_new = SimplePage.objects.get(id=self.child_page.id) # The page should be live now self.assertTrue(child_page_new.live) # And a revision with approved_go_live_at should not exist self.assertFalse(PageRevision.objects.filter(page=child_page_new).exclude(approved_go_live_at__isnull=True).exists()) def test_page_edit_post_submit(self): # Create a moderator user for testing email moderator = User.objects.create_superuser('moderator', '*****@*****.**', 'password') # Tests submitting from edit page post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-submit': "Submit", } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should be redirected to explorer page self.assertRedirects(response, reverse('wagtailadmin_explore', args=(self.root_page.id, ))) # The page should have "has_unpublished_changes" flag set child_page_new = SimplePage.objects.get(id=self.child_page.id) self.assertTrue(child_page_new.has_unpublished_changes) # The latest revision for the page should now be in moderation self.assertTrue(child_page_new.get_latest_revision().submitted_for_moderation) # Check that the moderator got an email self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, ['*****@*****.**']) self.assertEqual(mail.outbox[0].subject, 'The page "Hello world!" has been submitted for moderation') # Note: should this be "I've been edited!"? def test_page_edit_post_existing_slug(self): # This tests the existing slug checking on page edit # Create a page self.child_page = SimplePage() self.child_page.title = "Hello world 2" self.child_page.slug = "hello-world2" self.root_page.add_child(instance=self.child_page) # Attempt to change the slug to one thats already in use post_data = { 'title': "Hello world 2", 'slug': 'hello-world', 'action-submit': "Submit", } response = self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), post_data) # Should not be redirected (as the save should fail) self.assertEqual(response.status_code, 200) # Check that a form error was raised self.assertFormError(response, 'form', 'slug', "This slug is already in use") def test_preview_on_edit(self): post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-submit': "Submit", } response = self.client.post(reverse('wagtailadmin_pages_preview_on_edit', args=(self.child_page.id, )), post_data) # Check the response self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'tests/simple_page.html') self.assertContains(response, "I've been edited!")
class TestNotificationPreferences(TestCase, WagtailTestUtils): def setUp(self): # Find root page self.root_page = Page.objects.get(id=2) # Login self.user = self.login() # Create two moderator users for testing 'submitted' email self.moderator = User.objects.create_superuser('moderator', '*****@*****.**', 'password') self.moderator2 = User.objects.create_superuser('moderator2', '*****@*****.**', 'password') # Create a submitter for testing 'rejected' and 'approved' emails self.submitter = User.objects.create_user('submitter', '*****@*****.**', 'password') # User profiles for moderator2 and the submitter self.moderator2_profile = UserProfile.get_for_user(self.moderator2) self.submitter_profile = UserProfile.get_for_user(self.submitter) # Create a page and submit it for moderation self.child_page = SimplePage( title="Hello world!", slug='hello-world', live=False, ) self.root_page.add_child(instance=self.child_page) # POST data to edit the page self.post_data = { 'title': "I've been edited!", 'content': "Some content", 'slug': 'hello-world', 'action-submit': "Submit", } def submit(self): return self.client.post(reverse('wagtailadmin_pages_edit', args=(self.child_page.id, )), self.post_data) def silent_submit(self): """ Sets up the child_page as needing moderation, without making a request """ self.child_page.save_revision(user=self.submitter, submitted_for_moderation=True) self.revision = self.child_page.get_latest_revision() def approve(self): return self.client.post(reverse('wagtailadmin_pages_approve_moderation', args=(self.revision.id, )), { 'foo': "Must post something or the view won't see this as a POST request", }) def reject(self): return self.client.post(reverse('wagtailadmin_pages_reject_moderation', args=(self.revision.id, )), { 'foo': "Must post something or the view won't see this as a POST request", }) def test_vanilla_profile(self): # Check that the vanilla profile has rejected notifications on self.assertEqual(self.submitter_profile.rejected_notifications, True) # Check that the vanilla profile has approved notifications on self.assertEqual(self.submitter_profile.approved_notifications, True) def test_submit_notifications_sent(self): # Submit self.submit() # Check that both the moderators got an email, and no others self.assertEqual(len(mail.outbox), 1) self.assertIn(self.moderator.email, mail.outbox[0].to) self.assertIn(self.moderator2.email, mail.outbox[0].to) self.assertEqual(len(mail.outbox[0].to), 2) def test_submit_notification_preferences_respected(self): # moderator2 doesn't want emails self.moderator2_profile.submitted_notifications = False self.moderator2_profile.save() # Submit self.submit() # Check that only one moderator got an email self.assertEqual(len(mail.outbox), 1) self.assertEqual([self.moderator.email], mail.outbox[0].to) def test_approved_notifications(self): # Set up the page version self.silent_submit() # Approve self.approve() # Submitter must recieve an approved email self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, ['*****@*****.**']) self.assertEqual(mail.outbox[0].subject, 'The page "Hello world!" has been approved') def test_approved_notifications_preferences_respected(self): # Submitter doesn't want 'approved' emails self.submitter_profile.approved_notifications = False self.submitter_profile.save() # Set up the page version self.silent_submit() # Approve self.approve() # No email to send self.assertEqual(len(mail.outbox), 0) def test_rejected_notifications(self): # Set up the page version self.silent_submit() # Reject self.reject() # Submitter must recieve a rejected email self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, ['*****@*****.**']) self.assertEqual(mail.outbox[0].subject, 'The page "Hello world!" has been rejected') def test_rejected_notification_preferences_respected(self): # Submitter doesn't want 'rejected' emails self.submitter_profile.rejected_notifications = False self.submitter_profile.save() # Set up the page version self.silent_submit() # Reject self.reject() # No email to send self.assertEqual(len(mail.outbox), 0)