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)