class GetByUrlPathTestCase(ContentAPIBaseTestCase):
"""
Tests getting a page by its path.
"""
def setUp(self):
super().setUp()
self.page = ConditionPageFactory(title='Page')
def test_get(self):
"""
Tests that getting a page by its path returns 200 if it exists.
"""
response = self.get_content_api_response(page_path='conditions/page/')
self.assertEqual(response.status_code, 200)
content = response.json()
self.assertEqual(content['title'], self.page.title)
self.assertEqual(content['id'], self.page.id)
def test_404_if_url_doesnt_exist(self):
"""
Tests that trying to get a page by an invalid page returns 404
"""
response = self.get_content_api_response(page_path='invalid/')
self.assertEqual(response.status_code, 404)
def test_404_if_not_live(self):
"""
Tests that trying to get a page that is not live returns 404
"""
self.page.live = False
self.page.save()
response = self.get_content_api_response(page_path='conditions/page/')
self.assertEqual(response.status_code, 404)
class LivePagesTestCase(TestCase):
def setUp(self):
super().setUp()
self.page = ConditionPageFactory(title='Page')
self.request = self.get_request(Site.objects.first())
def get_request(self, site):
request = self.client.get('/test/', HTTP_HOST=site.hostname)
request.site = site
return request
@override_settings(FRONTEND_BASE_URL=TEST_FRONTEND_BASE_URL)
def test_live_page_redirects_to_frontend(self):
"""
Tests that the url /<page-url>/ redirects to <frontend-url>/<page-url>/ where
frontend-url == settings.FRONTEND_BASE_URL
if the page is live
"""
response = self.client.get(self.page.full_url)
expected_url = '{}{}'.format(TEST_FRONTEND_BASE_URL, self.page.url)
self.assertRedirects(response, expected_url, target_status_code=302)
def test_non_live_page_404s(self):
"""
Tests that the url /<page-url>/ returns 404 if the page is not live
"""
self.page.live = False
self.page.save()
response = self.client.get(self.page.full_url)
self.assertEqual(response.status_code, 404)
def test_non_existing_page_404s(self):
"""
Tests that if the invalid urls return 404
"""
invalid_url = '{}invalid/'.format(self.page.full_url)
response = self.client.get(invalid_url)
self.assertEqual(response.status_code, 404)
@override_settings(FRONTEND_BASE_URL='')
def test_placeholder_response_with_empty_settings(self):
"""
Tests that the url /<page-url>/ returns a placeholder string
if settings.FRONTEND_BASE_URL has not been set
"""
response = self.client.get(self.page.full_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content,
b'Please set FRONTEND_BASE_URL in your settings.py')
def setUp(self):
# set permissions
wagtailadmin_content_type, _ = ContentType.objects.get_or_create(
app_label='wagtailadmin', model='admin')
Permission.objects.get_or_create(
content_type=wagtailadmin_content_type,
codename='access_admin',
name='Can access Wagtail admin')
# login
self.user = self.login()
# create pages
self.page = ConditionPageFactory(title='Page')
self.revision = self.page.save_revision()
def setUp(self):
# set up images
self.image = ImageFactory(title='Test image')
# Set up pages
ConditionPageFactory(
title='condition-1', slug='condition-1',
main=EditorialPage._meta.get_field('main').to_python(
json.dumps([
{
'type': 'text',
'value': {
'variant': 'markdown',
'value': 'lorem ipsum'
},
},
{
'type': 'image',
'value': self.image.pk
}
])
)
)
self.url = reverse('export-content',)
# Login
self.login()
def test_import_existing_page(self, mocked_get_data_from_remote, mocked_get_list_of_children_from_remote):
title = 'test'
description = 'description'
ConditionPageFactory(title=title, slug=title, search_description='old text')
tot_pages = Page.objects.count()
mocked_get_list_of_children_from_remote.return_value = []
mocked_get_data_from_remote.return_value = {
'layout': 'content-simple',
'title': title,
'choicesOrigin': '',
'description': description,
'nonEmergencyCallout': True,
'content': {
'header': [],
'main': []
}
}
importer = Importer()
importer.import_items('conditions', [title])
self.assertEqual(importer.items_in_error, [])
self.assertEqual(Page.objects.count(), tot_pages)
page = EditorialPage.objects.get(slug='test')
self.assertEqual(page.title, title)
self.assertEqual(page.choices_origin, '')
self.assertEqual(page.search_description, description)
self.assertEqual(page.non_emergency_callout, True)
self.assertTrue(page.live)
def test_existing_pages_unselected(self, mocked_get_list_of_children_from_remote):
mocked_get_list_of_children_from_remote.side_effect = self.get_mocked_list_of_children()
ConditionPageFactory(title='condition-2', slug='condition-2')
ConditionPageFactory(title='different-condition', slug='different-condition')
SymptomPageFactory(title='symptom-3', slug='symptom-3')
form = ImportForm()
self.assertEqual(
form.fields['conditions'].initial,
['condition-1', 'condition-3']
)
self.assertEqual(
form.fields['symptoms'].initial,
['symptom-1', 'symptom-2']
)
def setUp(self):
"""
Creates:
root
homepage
conditions (live)
level1-a (live)
level1-b (draft)
level1-c (live)
level2-c (live)
"""
super().setUp()
ConditionsPageFactory()
ConditionPageFactory(title='level1-a live', slug='level1-a', live=True)
ConditionPageFactory(title='level1-b draft', slug='level1-b', live=False)
level1c = ConditionPageFactory(title='level1-c live', slug='level1-c', live=True)
ConditionPageFactory(
title='level2-c live', slug='level2-c', live=True,
depth=level1c.depth + 1,
path='{}0001'.format(level1c.path)
)
def setUp(self):
super().setUp()
self.page = ConditionPageFactory(title='Page')
def setUp(self):
super().setUp()
self.page = ConditionPageFactory(title='Page')
self.request = self.get_request(Site.objects.first())
class PreviewPagesTestCase(ContentAPIBaseTestCase):
"""
Tests getting the content of a page by its revision id.
"""
def setUp(self):
super().setUp()
self.page = ConditionPageFactory(title='Page')
def test_get_by_revision_x(self):
"""
Tests that getting a page by its revision id returns the related content, not the live one.
"""
# save some revisions
revision_data = []
for change_number in range(1, 3):
self.page.title = 'Page change {}'.format(change_number)
self.page.save()
revision = self.page.save_revision()
revision_data.append((revision.id, self.page.title))
# get those versions and check that page.title == saved title
for revision_id, page_title in revision_data:
response = self.get_preview_content_api_response(
self.page.id, revision_id=revision_id)
content = response.json()
self.assertEqual(response.status_code, 200)
self.assertEqual(content['title'], page_title)
def test_404_if_revision_doesnt_exist(self):
"""
Tests that trying to get a page by an invalid revision returns 404.
"""
# save a few revisions
for change_number in range(1, 3):
self.page.title = 'Page change {}'.format(change_number)
self.page.save()
self.page.save_revision()
# get invalid revision id (last id + 1)
revision_id = PageRevision.objects.order_by('-id')[0].id + 1
response = self.get_preview_content_api_response(
self.page.id, revision_id=revision_id)
self.assertEqual(response.status_code, 404)
def test_get_defaults_to_latest_revision(self):
"""
Tests that getting a page without specifying a revision id returns the latest version.
"""
# save some revisions
latest_title = self.page.title
for change_number in range(1, 3):
self.page.title = 'Page change {}'.format(change_number)
self.page.save()
self.page.save_revision()
latest_title = self.page.title
# check that returned content.title == latest title
response = self.get_preview_content_api_response(self.page.id)
content = response.json()
self.assertEqual(response.status_code, 200)
self.assertEqual(content['title'], latest_title)