def test_get_latest_release_returns_the_newest_release_with_date( self, mock_file_service): """ A published release is one whose release_time is in the past. """ release1_name = 'Next release' release1_date = None release1 = create_test_release(release_name=release1_name, release_date=release1_date) release2_name = 'Future release 1' release2_date = None release2 = create_test_release(release_name=release2_name, release_date=release2_date) release3_name = 'Future release 2' release3_date = timezone.now() + timedelta(days=+2) release3 = create_test_release(release_name=release3_name, release_date=release3_date) latest_release = get_latest_release(release1.site_id) self.assertIsFalse(release1.release_date_has_passed()) self.assertIsFalse(release2.release_date_has_passed()) self.assertIsFalse(release3.release_date_has_passed()) self.assertEqual(latest_release.id, release3.id)
def test_get_latest_live_release_returns_the_newest_published_release( self, mock_file_service): """ A published release is one whose release_time is in the past. """ release1_name = 'Old release' release1_date = timezone.now() + timedelta(days=-10) release1 = create_test_release(release_name=release1_name, release_date=release1_date) release2_name = 'Current release' release2_date = timezone.now() + timedelta(days=-1) release2 = create_test_release(release_name=release2_name, release_date=release2_date) release3_name = 'Future release' release3_date = timezone.now() + timedelta(days=+10) release3 = create_test_release(release_name=release3_name, release_date=release3_date) current_release = get_latest_live_release(release1.site_id) self.assertIsTrue(release1.release_date_has_passed()) self.assertIsTrue(release2.release_date_has_passed()) self.assertIsFalse(release3.release_date_has_passed()) self.assertEqual(current_release.id, release2.id)
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_query_set_to_dict_returns_an_array_of_dicts_for_objects( self, mock_file_service): create_test_release() create_test_release(release_name='Test release 2') releases = Release.objects.all() dicts = query_set_to_dict(releases) self.assertEqual(len(releases), len(dicts)) self.assertEqual(type(dicts[0]), dict)
def test_get_queryset_returns_all_the_releases_in_the_db( self, mock_file_service): create_test_release() release_admin = ReleaseAdmin() request = HttpRequest() admin_release_list = release_admin.get_queryset(request) expected_release_count = Release.objects.count() self.assertEqual(expected_release_count, admin_release_list.count())
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_publishing_recipe_page_to_release_links_new_revision_to_release( self, mock_file_service): page = create_test_recipe_page() initial_revision = page.get_latest_revision() release = create_test_release() 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_view_no_live_release(self, mock_file_service, mock_index_file): release = create_test_release() c = Client() response = c.get('/admin/release/release/view/{}/'.format(release.id)) self.assertIsTrue( response.context.get('error_msg') == 'No live release')
def test_is_released_returns_false_if_now_date_set(self, mock_file_service): """ the is released function should return false if the release date hasn't been set. """ release = create_test_release() self.assertIsFalse(release.release_date_has_passed())
def test_is_released_returns_true_if_date_is_in_the_past( self, mock_file_service): """ the is released function should return true if the release date is in the past. """ release = create_test_release() release.release_time = timezone.now() + timedelta(days=-1) self.assertIsTrue(release.release_date_has_passed())
def test_to_dict_removes_empty_fields(self, mock_file_service): """ to_dict method should return a dictionary representing the object """ test_name = 'Test release' release = create_test_release(test_name) release_dict = release.dict() self.assertIs(release_dict['release_name'], test_name) self.assertIsFalse('release_time' in release_dict)
def test_is_released_returns_false_if_date_is_in_the_future( self, mock_file_service): """ the is released function should return false if the release date is in the future. """ release = create_test_release() release.release_time = timezone.now() + timedelta(days=1) self.assertIsFalse(release.release_date_has_passed())
def test_release_loads_none_object_if_the_requested_page_isnt_in_release( self, mock_file_service): """ When content is requested for a release that isn't included in the release a None object should be returned. """ release = create_test_release() with self.assertRaises(KeyError): release.get_content_for(0)
def test_get_release_object_returns_the_correct_release( self, mock_file_service): release = create_test_release() release_uuid = release.uuid loaded_release = get_release_object(release_uuid) self.assertEqual(release.id, loaded_release.id) self.assertEqual(release.release_name, loaded_release.release_name)
def test_to_dict(self, mock_file_service): """ to_dict method should return a dictionary representing the object """ test_name = 'Test release' test_date = timezone.now() release = create_test_release(test_name, test_date) release_dict = release.dict() self.assertIs(release_dict['release_name'], test_name) self.assertEqual(release_dict['release_time'], test_date.timestamp())
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_release_content_returns_none_if_the_requested_page_not_in_release( self, mock_file_service): """ When a page is requested that isn't included in a release a None object should be returned. """ release = create_test_release() site_name = 'oneyou' SiteSettings(site_id=release.site_id, uid=site_name).save() release_content = release.content.first() # release_content = create_test_release_content(release, json.dumps(release.generate_fixed_content())) self.assertRaises(KeyError, release_content.get_content_for, '0')
def test_preview_button_returns_a_link_to_view_the_releases_content( self, mock_file_service): create_test_site_settings() release = create_test_release() release_admin = ReleaseAdmin() view = IndexView(release_admin) request = HttpRequest() release_button_helper = ReleaseButtonHelper(view, request) preview_button = release_button_helper.preview_button(release.id) expected_release_url = '/' + release.site.sitesettings.uid + '/?id=' + release.uuid self.assertEqual(preview_button['url'], expected_release_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_html_sets_cache_timeout_to_15_seconds( self, mock_file_service, mock_index_file): site_settings = create_test_site_settings() site_name = site_settings.uid http_host = 'phe.nhs.uk.com' request = HttpRequest() request.META['HTTP_HOST'] = http_host request.path = 'test' release = create_test_release( release_date=(timezone.now() + timezone.timedelta(days=-1))) release.content_status = 1 release.save() response = release_html(request, site_name) self.assertEquals(response['Cache-Control'], 'max-age=900')
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_release_html_sets_api_url_to_local_if_local_in_host_name( self, mock_file_service, mock_index_file): site_settings = create_test_site_settings() site_name = site_settings.uid http_host = 'localhost:3000' request = HttpRequest() request.META['HTTP_HOST'] = http_host request.path = 'test' release = create_test_release( release_date=(timezone.now() + timezone.timedelta(days=-1))) release.content_status = 1 release.save() response = release_html(request, site_name) response_content_string = response.content.decode('utf-8') self.assertIsTrue(http_host + '/api' in response_content_string)
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_release_html_endpoint_returns_an_index_with_substituted_values( self, mock_file_service, mock_index_file): release_date = timezone.now() + timedelta(days=-1) release = create_test_release(release_date=release_date) site_name = 'oneyou' SiteSettings(site_id=release.site_id, uid=site_name).save() http_host = 'phe.nhs.uk' request = HttpRequest() request.META['HTTP_HOST'] = http_host response = release_html(request, site_name) response_content_string = response.content.decode('utf-8') self.assertIsFalse('{{ api_url }}' in response_content_string) self.assertIsFalse('{{ site_setting.uid }}' in response_content_string) self.assertIsFalse('{{ release_id }}' in response_content_string) self.assertIsTrue(release.uuid in response_content_string)
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_get_btns_for_obj_returns_a_list_containing_preview_button( self, mock_file_service): create_test_site_settings() release = create_test_release() release_admin = ReleaseAdmin() view = IndexView(release_admin) request = WSGIRequest({'REQUEST_METHOD': 'GET', 'wsgi.input': ''}) request.user = create_test_user() release_button_helper = ReleaseButtonHelper(view, request) buttons = release_button_helper.get_buttons_for_obj(release) preview_in_buttons = False for btn in buttons: if btn['label'] == 'preview': preview_in_buttons = True self.assertIsTrue(preview_in_buttons)
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'])