def test_breadcrumbs_property(self):
parent_page = create_test_page(SexHealthPage)
child_page1 = create_test_page(SexHealthPage, parent_page)
self.assertEquals(len(child_page1.breadcrumbs), 2)
self.assertEquals(child_page1.breadcrumbs[-1]['name'],
parent_page.title)
self.assertEquals(child_page1.breadcrumbs[-1]['url'],
parent_page.link_url)
def test_remove_page_does_nothing_if_the_page_is_not_in_the_release(
self, mock_file_service):
"""
the remove page function should not remove anything if the page is not in the release.
"""
release = create_test_release()
page1 = create_test_page(OneYouPage, None, title='Page 1')
page1.release = release
page1.save_revision()
page2 = create_test_page(OneYouPage, None, title='Page 2', path='1112')
page2.release = release
page2.save_revision()
page3 = create_test_page(OneYouPage, None, title='Page 3', path='1113')
page1_in_release = False
page2_in_release = False
page3_in_release = False
content = json.loads(release.content.first().content)
if str(page1.id) in content:
page1_in_release = True
if str(page2.id) in content:
page2_in_release = True
if str(page3.id) in content:
page3_in_release = True
self.assertIsTrue(page1_in_release)
self.assertIsTrue(page2_in_release)
self.assertIsFalse(page3_in_release)
release.remove_page(page3.id)
page1_in_release = False
page2_in_release = False
page3_in_release = False
content = json.loads(release.content.first().content)
if str(page1.id) in content:
page1_in_release = True
if str(page2.id) in content:
page2_in_release = True
if str(page3.id) in content:
page3_in_release = True
self.assertIsTrue(page1_in_release)
self.assertIsTrue(page2_in_release)
self.assertIsFalse(page3_in_release)
def test_release_doesnt_lock_content_if_no_release_time_set(
self, mock_file_service):
"""
when a release is requested with no release date, it should not save the content into json.
"""
create_test_page(OneYouPage)
release_name = 'Unset release'
create_test_release(release_name)
loaded_release = Release.objects.get(release_name=release_name)
self.assertEqual(loaded_release.content_status, 0)
def test_release_doesnt_lock_content_before_its_release_time(
self, mock_file_service):
"""
when a release is requested before its release date, it should not save the content into json.
"""
create_test_page(OneYouPage)
release_name = 'Future release'
release_date = timezone.now() + timedelta(days=1)
create_test_release(release_name, release_date)
loaded_release = Release.objects.get(release_name=release_name)
self.assertEqual(loaded_release.content_status, 0)
def test_add_revision_creates_a_new_link_if_the_page_not_already_in_the_release(
self, mock_file_service):
"""
when a revision is added to a release it creates a new link if the page not already linked to the release.
"""
page = create_test_page(OneYouPage)
initial_revision = page.get_latest_revision()
self.assertIsNotNone(initial_revision)
release = create_test_release()
page.release = release
page.save_revision()
initial_revision_in_release = False\
content = json.loads(release.content.first().content)
if str(initial_revision.page_id) in content:
initial_revision_in_release = True
self.assertIsTrue(initial_revision_in_release)
release_content = release.content.first()
release_content_dict = json.loads(release_content.content)
self.assertEquals(len(release_content_dict), 1)
page2 = create_test_page(OneYouPage, None, title='Page 2', path='1112')
second_revision = page2.get_latest_revision()
release.add_revision(second_revision)
initial_revision_in_release = False
second_revision_in_release = False
content = json.loads(release.content.first().content)
if str(initial_revision.page_id) in content:
initial_revision_in_release = True
if str(second_revision.page_id) in content:
second_revision_in_release = True
release_content = release.content.first()
release_content_dict = json.loads(release_content.content)
self.assertEquals(len(release_content_dict), 2)
self.assertIsTrue(initial_revision_in_release)
self.assertIsTrue(second_revision_in_release)
def test_replace_internal_links_correctly_returns_a_tag_with_hrf(self):
page = create_test_page(OneYouPage)
rich_text_source = '<p><a id="{}" linktype="page">link 1</a></p>'.format(page.id)
processed_content = process_inlines(rich_text_source)
self.assertNotEquals(rich_text_source, processed_content)
self.assertIsTrue('<a' in processed_content)
self.assertIsTrue('href="' in processed_content)
def test_publishing_page_to_release_links_new_revision_to_release(
self, mock_file_service):
page = create_test_page(SexHealthPage)
initial_revision = page.get_latest_revision()
release = create_test_release(SexHealthPage)
page.release = release
page.title = 'Updated page'
page.save_revision().publish()
second_revision = page.get_latest_revision()
initial_revision_in_release = False
second_revision_in_release = False
content = json.loads(release.content.first().content)
if content[str(
page.id)]['title'] == initial_revision.as_page_object().title:
initial_revision_in_release = True
if content[str(
page.id)]['title'] == second_revision.as_page_object().title:
second_revision_in_release = True
self.assertTrue(second_revision_in_release)
self.assertIsFalse(initial_revision_in_release)
def test_release_loads_content_from_locked_content_if_released(
self, mock_file_service):
"""
When content is requested for a release after it is released it should load the content from the locked content
not from the releated tables.
"""
initial_title = 'Test page'
page = create_test_page(OneYouPage, None, initial_title)
revision = page.get_latest_revision()
release_time = timezone.now() + timedelta(days=-1)
release = create_test_release(release_date=release_time)
populate_release_if_required(release)
loaded_release = Release.objects.get(id=release.id)
page.release = release
page.save_revision()
second_title = 'Altered page'
page.title = second_title
page.save_revision()
revision.content_json = page.to_json()
revision.save()
release_page_content = loaded_release.get_content_for(page.id)
self.assertIsNotNone(release.content_status, 1)
self.assertIsNotNone(release_page_content)
self.assertNotEqual(
json.loads(revision.content_json)['title'], initial_title)
self.assertEqual(release_page_content['title'], initial_title)
def test_release_initialised_from_a_base_release_gets_revisions_from_base(
self, mock_file_service):
"""
when a release is initialised from an existing release as a base it gets linked to the same pages the base
release is linked to at that point.
"""
page = create_test_page(OneYouPage)
release_name = 'Base release'
base_release = create_test_release(release_name)
page.release = base_release
page.save_revision().publish()
base_release_content = base_release.content.first()
base_release_content_dict = json.loads(base_release_content.content)
self.assertEquals(len(base_release_content_dict), 1)
new_release = create_test_release(base_release=base_release)
new_release_content = new_release.content.first()
new_release_content_dict = json.loads(new_release_content.content)
self.assertEquals(len(new_release_content_dict), 1)
self.assertEquals(
list(base_release_content_dict.keys())[0],
list(new_release_content_dict.keys())[0])
def test_release_locks_content_after_its_release_time(
self, mock_file_service):
"""
when a release is requested after its release date, it should save the content into json.
"""
create_test_page(OneYouPage)
release_name = 'Past release'
release_date = timezone.now() + timedelta(days=-1)
release = create_test_release(release_name, release_date)
populate_release_if_required(release)
loaded_release = Release.objects.get(release_name=release_name)
self.assertEqual(loaded_release.content.count(), 1)
self.assertEqual(loaded_release.content_status, 1)
def test_get_serializable_data_for_fields_correctly_serialises_the_page(self):
page = create_test_page(OneYouPage)
field = OneYouPage._meta.get_field('body')
page.body = StreamValue(field.stream_block,
[('section_heading_shelf',
StructValue([('heading', 'This is a section heading'), ('shelf_id', 'shelf1')]))])
serialized_data = get_serializable_data_for_fields(page)
self.assertEqual(type(serialized_data), dict)
def test_release_view_compare_to_live_release(self, mock_file_service,
mock_index_file):
# Create a live release with 2 pages
live_release = create_test_release(
'Live release',
release_date=(timezone.now() + timezone.timedelta(days=-1)))
test_live_page1 = create_test_page(OneYouPage)
test_live_page1.release = live_release
test_live_page1.live_revision = test_live_page1.save_revision()
test_live_page2 = create_test_page(OneYouPage)
test_live_page2.release = live_release
test_live_page2.live_revision = test_live_page2.save_revision()
# Create current release edit page1 from live release, remove a page2 live release
# and create a new page3
current_release = create_test_release()
test_live_page1.release = current_release
test_live_page1.live_revision = test_live_page1.save_revision()
current_release.remove_page(test_live_page2.id)
test_live_page3 = create_test_page(OneYouPage)
test_live_page3.release = current_release
test_live_page3.live_revision = test_live_page3.save_revision()
test_live_page3.save()
c = Client()
response = c.get('/admin/release/release/view/{}/'.format(
current_release.id))
self.assertIsTrue(response.context.get('release') == current_release)
self.assertIsTrue(response.context.get('error_msg') == '')
self.assertIsTrue(
response.context.get('pages')[test_live_page1.id]['status'] ==
'updated')
self.assertIsTrue(
response.context.get('pages')[test_live_page2.id]['status'] ==
'removed')
self.assertIsTrue(
response.context.get('pages')[test_live_page3.id]['status'] ==
'new')
def test_a_release_page_object_returns_associated_release(
self, mock_file_service):
release = create_test_release()
page = create_test_page(OneYouPage)
revision = page.get_latest_revision()
release_page = create_test_release_page(release, revision)
self.assertEqual(type(revision), type(release_page.revision))
self.assertEqual(type(release), type(release_page.release))
def test_remove_page_removes_the_linked_revision_of_the_page_from_the_release(
self, mock_file_service):
"""
the remove page function should remove any linked revisions of that page from the release.
"""
release = create_test_release()
page1 = create_test_page(OneYouPage, None, title='Page 1')
page1.release = release
page1.save_revision()
page2 = create_test_page(OneYouPage, None, title='Page 2', path='1112')
page2.release = release
page2.save_revision()
page1_in_release = False
page2_in_release = False
content = json.loads(release.content.first().content)
if str(page1.id) in content:
page1_in_release = True
if str(page2.id) in content:
page2_in_release = True
self.assertIsTrue(page1_in_release)
self.assertIsTrue(page2_in_release)
release.remove_page(page2.id)
page1_in_release = False
page2_in_release = False
content = json.loads(release.content.first().content)
if str(page1.id) in content:
page1_in_release = True
if str(page2.id) in content:
page2_in_release = True
self.assertIsTrue(page1_in_release)
self.assertIsFalse(page2_in_release)
def test_add_revision_replaces_the_linked_revision_of_a_page_with_the_new_revision(
self, mock_file_service):
"""
when a revision is added to a release it replaces the existing revision linked to the release.
"""
page = create_test_page(OneYouPage)
initial_revision = page.get_latest_revision()
self.assertIsNotNone(initial_revision)
release = create_test_release()
page.release = release
page.save_revision()
initial_revision_in_release = False
content = json.loads(release.content.first().content)
if content[str(
page.id)]['title'] == initial_revision.as_page_object().title:
initial_revision_in_release = True
self.assertIsTrue(initial_revision_in_release)
page.title = 'Updated page'
page.save_revision().publish()
second_revision = page.get_latest_revision()
self.assertNotEqual(initial_revision.id, second_revision.id)
release.add_revision(second_revision)
initial_revision_in_release = False
second_revision_in_release = False
content = json.loads(release.content.first().content)
if content[str(
page.id)]['title'] == initial_revision.as_page_object().title:
initial_revision_in_release = True
if content[str(
page.id)]['title'] == second_revision.as_page_object().title:
second_revision_in_release = True
self.assertIsFalse(initial_revision_in_release)
self.assertIsTrue(second_revision_in_release)
def test_release_content_can_return_a_requested_page(
self, mock_file_service):
"""
When a specific page is requested from the locked content it should be retrievable.
"""
page = create_test_page(OneYouPage, None, title='First Page')
self.assertIsNotNone(page.get_latest_revision())
release = create_test_release()
page.release = release
page.save_revision()
# release_content = create_test_release_content(release, json.dumps(release.generate_fixed_content()))
release_content = release.content.first()
loaded_page_content = release_content.get_content_for(str(page.id))
self.assertEqual(page.title, loaded_page_content['title'])
def test_on_create_release_is_linked_to_all_current_pages(
self, mock_file_service):
"""
when a new release is created it should be linked to the latest revisions of all live pages.
"""
page = create_test_page(OneYouPage)
release = create_test_release()
page.release = release
page.save_revision()
count_of_pages = OneYouPage.objects.count()
release_content = release.content.first()
release_content_dict = json.loads(release_content.content)
self.assertEqual(count_of_pages, len(release_content_dict))
self.assertEqual(str(page.id), list(release_content_dict.keys())[0])
def test_unpublishing_a_page_removes_the_revision_for_that_page_from_the_release(
self, mock_file_service):
page = create_test_page(SexHealthPage)
release = create_test_release()
page.release = release
page.save_revision()
page_count = SexHealthPage.objects.count()
live_page_count = SexHealthPage.objects.live().count()
release_content = release.content.first()
release_content_dict = json.loads(release_content.content)
self.assertEquals(page_count, len(release_content_dict))
self.assertEquals(live_page_count, len(release_content_dict))
revision_in_release = False
if str(page.id) in release_content_dict:
revision_in_release = True
self.assertTrue(revision_in_release)
page.release = release
page.unpublish(release.id)
page_count = SexHealthPage.objects.count()
# live_page_count = SexHealthPage.objects.live().count()
release_content = release.content.first()
release_content_dict = json.loads(release_content.content)
self.assertNotEquals(page_count, len(release_content_dict))
# self.assertEquals(live_page_count, len(release_content_dict))
revision_in_release = False
if str(page.id) in release_content_dict:
revision_in_release = True
self.assertIsFalse(revision_in_release)
def test_release_loads_content_from_tables_if_not_yet_released(
self, mock_file_service):
"""
When content is requested for a release before it is released it should load the content from the related tables
not from locked content. Tested by checking that before it is released it returns any content, because before
its released there is not locked content to load from.
"""
page = create_test_page(OneYouPage)
revision = page.get_latest_revision()
release_time = timezone.now() + timedelta(days=1)
release = create_test_release(release_date=release_time)
page.release = release
page.save_revision()
release_page_content = release.get_content_for(page.id)
self.assertIsNotNone(release_page_content)
self.assertEqual(release_page_content['title'],
json.loads(revision.content_json)['title'])
def setUp(self):
self.release = create_test_release()
self.page = create_test_page(OneYouPage)
self.user = create_test_user()
def test_page_preview_modes_function_returns_the_correct_options(self):
page = create_test_page(SexHealthPage)
self.assertEquals(page.preview_modes,
SexHealthPage.DEFAULT_PREVIEW_MODES)
def test_page_default_preview_mode_returns_the_correct_option(self):
page = create_test_page(SexHealthPage)
default_preview_mode = 'react'
self.assertEquals(page.default_preview_mode, default_preview_mode)