def test_get_latest_version_of_all_measures(self): measure_1_version_1_0 = MeasureVersionFactory( version="1.0", status="APPROVED", title="Measure 1 version 1.0") measure_1_version_2_0 = MeasureVersionFactory( version="2.0", status="DRAFT", title="Measure 1 version 2.1", measure=measure_1_version_1_0.measure) measure_2_version_1_0 = MeasureVersionFactory( version="1.0", status="APPROVED", title="Measure 2 version 1.0", measure__subtopics=measure_1_version_1_0.measure.subtopics, ) measure_2_version_1_1 = MeasureVersionFactory( version="1.1", status="APPROVED", title="Measure 2 version 2.0", measure=measure_2_version_1_0.measure) assert page_service.get_latest_version_of_all_measures( include_not_published=False) == [ measure_1_version_1_0, measure_2_version_1_1, ] assert page_service.get_latest_version_of_all_measures( include_not_published=True) == [ measure_1_version_2_0, measure_2_version_1_1, ]
def test_merge_from_two_other_data_sources(self, db_session): data_source_1 = DataSourceFactory.create() data_source_2 = DataSourceFactory.create() data_source_3 = DataSourceFactory.create() measure_version_associated_with_data_source_2 = MeasureVersionFactory.create( data_sources=[data_source_2]) second_measure_version_associated_with_data_source_2 = MeasureVersionFactory.create( data_sources=[data_source_2]) measure_version_associated_with_data_source_3 = MeasureVersionFactory.create( data_sources=[data_source_3]) data_source_1.merge( data_source_ids=[data_source_2.id, data_source_3.id]) db_session.session.commit() assert DataSource.query.get(data_source_2.id) is None assert DataSource.query.get(data_source_3.id) is None assert measure_version_associated_with_data_source_2.data_sources == [ data_source_1 ] assert second_measure_version_associated_with_data_source_2.data_sources == [ data_source_1 ] assert measure_version_associated_with_data_source_3.data_sources == [ data_source_1 ]
def test_internal_user_can_not_see_publish_buttons_on_edit_page( test_app_client, logged_in_rdu_user): measure_version = MeasureVersionFactory(status="DEPARTMENT_REVIEW") response = test_app_client.get( url_for( "cms.edit_measure_version", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, ), follow_redirects=True, ) page = BeautifulSoup(response.data.decode("utf-8"), "html.parser") assert page.find_all("button", text=re.compile("Reject")) measure_version = MeasureVersionFactory(status="APPROVED") response = test_app_client.get( url_for( "cms.edit_measure_version", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, ), follow_redirects=True, ) page = BeautifulSoup(response.data.decode("utf-8"), "html.parser") assert page.find_all("a", text=re.compile("Update"))
def test_rdu_user_cans_see_latest_draft_version(test_app_client, logged_in_rdu_user): measure = MeasureFactory(shared_with=[]) MeasureVersionFactory(title="Old Test Measure Page", status="APPROVED", measure=measure, version="1.0") MeasureVersionFactory(title="Updated Test Measure Page", status="DRAFT", measure=measure, version="2.0") resp = test_app_client.get( url_for( "static_site.measure_version", topic_slug=measure.subtopic.topic.slug, subtopic_slug=measure.subtopic.slug, measure_slug=measure.slug, version="latest", )) assert resp.status_code == 200 page = BeautifulSoup(resp.data.decode("utf-8"), "html.parser") assert page.h1.text.strip() == "Updated Test Measure Page"
def test_later_version_shows_links_to_earlier_versions( self, test_app_client, logged_in_admin_user): # GIVEN a page with a later published version measure = MeasureFactory() # Published version 1.0 measure_1_0 = MeasureVersionFactory(measure=measure, status="APPROVED", latest=False, version="1.0", published_at=datetime.datetime( 2018, 3, 29)) # Published version 1.1 measure_1_1 = MeasureVersionFactory(measure=measure, status="APPROVED", latest=False, version="1.1", published_at=datetime.datetime( 2019, 3, 29)) # Latest published version 2.0 measure_2_0 = MeasureVersionFactory(measure=measure, status="APPROVED", latest=True, version="2.0") measure_1_0_url = url_for( "static_site.measure_version", topic_slug=measure_1_0.measure.subtopic.topic.slug, subtopic_slug=measure_1_0.measure.subtopic.slug, measure_slug=measure_1_0.measure.slug, version=measure_1_0.version, ) measure_1_1_url = url_for( "static_site.measure_version", topic_slug=measure_1_1.measure.subtopic.topic.slug, subtopic_slug=measure_1_1.measure.subtopic.slug, measure_slug=measure_1_1.measure.slug, version=measure_1_1.version, ) measure_2_0_url = url_for( "static_site.measure_version", topic_slug=measure_2_0.measure.subtopic.topic.slug, subtopic_slug=measure_2_0.measure.subtopic.slug, measure_slug=measure_2_0.measure.slug, version=measure_2_0.version, ) # WHEN we get the latest measure page resp = test_app_client.get(measure_2_0_url) # THEN it should contain a link to the latest minor version of the earlier published version assert resp.status_code == 200 page = BeautifulSoup(resp.data.decode("utf-8"), "html.parser") measure_1_1_links = page.find_all("a", attrs={"href": measure_1_1_url}) assert len(measure_1_1_links) == 1 assert measure_1_1_links[ 0].text == "Edition published on 29 March 2019" # AND should not contain a link to the superseded earlier version measure_1_0_links = page.find_all("a", attrs={"href": measure_1_0_url}) assert len(measure_1_0_links) == 0
def test_measure_version_history_page(test_app_client, logged_in_dev_user): measure_version_1_0 = MeasureVersionFactory(status="APPROVED", latest=False, version="1.0") measure_version_1_1 = MeasureVersionFactory( status="APPROVED", latest=True, version="1.1", measure=measure_version_1_0.measure) topic_slug = measure_version_1_0.measure.subtopic.topic.slug subtopic_slug = measure_version_1_0.measure.subtopic.slug measure_slug = measure_version_1_0.measure.slug response = test_app_client.get( url_for("cms.list_measure_versions", topic_slug=topic_slug, subtopic_slug=subtopic_slug, measure_slug=measure_slug)) assert response.status_code == 200 page = BeautifulSoup(response.data.decode("utf-8"), "html.parser") assert "Version history" in page.find("h1").text.strip() assert measure_version_1_1.title in page.find("h1").text.strip() view_form_links = page.findAll("a", text=re.compile(r"View\s+form")) view_form_hrefs = [element.attrs["href"] for element in view_form_links] assert view_form_hrefs == [ f"/cms/{topic_slug}/{subtopic_slug}/{measure_slug}/1.1/edit", f"/cms/{topic_slug}/{subtopic_slug}/{measure_slug}/1.0/edit", ]
def test_404_if_data_source_not_associated_with_measure_version( self, test_app_client, logged_in_rdu_user): measure_version = MeasureVersionFactory(data_sources=[]) data_source = DataSourceFactory() res = test_app_client.post( url_for( "cms.remove_data_source", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, data_source_id=data_source.id, ), follow_redirects=True, ) assert res.status_code == 404 measure_version.data_sources = [data_source] res = test_app_client.post( url_for( "cms.remove_data_source", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, data_source_id=data_source.id, ), follow_redirects=True, ) assert res.status_code == 200
def test_data_source_associated_with_published_measure_versions(self): data_source_1 = DataSourceFactory.create() MeasureVersionFactory.create(data_sources=[data_source_1], status="APPROVED") data_source_2 = DataSourceFactory.create() MeasureVersionFactory.create(data_sources=[data_source_2], status="DRAFT") assert data_source_1.associated_with_published_measure_versions is True assert data_source_2.associated_with_published_measure_versions is False
def test_script_creates_one_new_measure_version_and_updates_dimension_titles_for_two_dimensions( self, single_use_app, db_session ): user = UserFactory(user_type=TypeOfUser.ADMIN_USER, email="*****@*****.**") mv = MeasureVersionFactory.build( status="APPROVED", version="1.0", title="my measure", measure__id=1, uploads=[] ) mv.dimensions = [ DimensionFactory.build(guid="dimension-guid-1", title="my dimension 1"), DimensionFactory.build(guid="dimension-guid-2", title="my dimension 2"), ] db_session.session.add(mv) db_session.session.commit() dimension_rows = [ ["dimension-guid-1", "my measure", "my dimension 1", "my new dimension 1"], ["dimension-guid-2", "my measure", "my dimension 2", "my new dimension 2"], ] import_dimension_titles(user_email=user.email, app=single_use_app, dimension_rows=dimension_rows) measure = Measure.query.get(1) assert len(measure.versions) == 2 assert measure.versions[0].version == "1.1" assert measure.versions[0].status == "APPROVED" assert measure.versions[0].dimensions[0].title == "my new dimension 1" assert measure.versions[0].dimensions[1].title == "my new dimension 2" assert measure.versions[0].external_edit_summary == STANDARD_EDIT_SUMMARY assert measure.versions[1].version == "1.0" assert measure.versions[1].dimensions[0].title == "my dimension 1" assert measure.versions[1].dimensions[1].title == "my dimension 2"
def test_new_measure_version_not_created_if_any_new_dimension_titles_are_blank(self, single_use_app, db_session): user = UserFactory(user_type=TypeOfUser.ADMIN_USER, email="*****@*****.**") mv = MeasureVersionFactory.build( status="APPROVED", version="1.0", title="my measure", measure__id=1, uploads=[] ) mv.dimensions = [ DimensionFactory.build(guid="dimension-guid-1", title="my dimension 1"), DimensionFactory.build(guid="dimension-guid-2", title="my dimension 2"), ] db_session.session.add(mv) db_session.session.commit() dimension_rows = [ ["dimension-guid-1", "my measure", "my dimension 1", ""], ["dimension-guid-2", "my measure", "my dimension 2", "my new dimension 2"], ] error_count = import_dimension_titles(user_email=user.email, app=single_use_app, dimension_rows=dimension_rows) measure = Measure.query.get(1) assert error_count == 0 assert len(measure.versions) == 1 assert measure.versions[0].version == "1.0" assert measure.versions[0].dimensions[0].title == "my dimension 1" assert measure.versions[0].dimensions[1].title == "my dimension 2"
def test_add_or_update_dimensions_to_measure_page_preserves_order(): measure_version = MeasureVersionFactory() assert measure_version.dimensions.count() == 0 d1 = dimension_service.create_dimension( measure_version, title="test-dimension-1", time_period="time_period", summary="summary" ) d2 = dimension_service.create_dimension( measure_version, title="test-dimension-2", time_period="time_period", summary="summary" ) assert measure_version.dimensions[0].title == d1.title assert d1.position == 0 assert measure_version.dimensions[0].position == d1.position assert measure_version.dimensions[1].title == "test-dimension-2" assert d2.position == 1 assert measure_version.dimensions[1].position == d2.position # after update. positions should not have changed dimension_service.update_dimension(d1, {"summary": "updated summary"}) assert d1.summary == "updated summary" assert d1.position == 0 assert d2.position == 1
def test_adding_chart_with_data_matching_an_ethnicity_classification(two_classifications_2A_5A): # Given an existing dimension with no associated chart dimension = dimension_service.create_dimension( MeasureVersionFactory(), title="test-dimension", time_period="time_period", summary="summary" ) # When update_dimension is called with chart data with classification code '2A' and use_custom False dimension_service.update_dimension( dimension, { "use_custom": False, "chart": {"title": "My chart title"}, "chart_settings_and_source_data": {"chartOptions": {}}, "classification_code": "5A", "ethnicity_values": ["All", "Asian", "Black", "Mixed", "White", "Other", "Unknown"], }, update_classification=True, ) # refresh the dimension from the database dimension = Dimension.query.get(dimension.guid) # Then the classification is set on dimension_chart with flags calculated from ethnicity_values assert dimension.dimension_chart is not None assert dimension.dimension_chart.classification_id == "5A" assert dimension.dimension_chart.includes_parents is False assert dimension.dimension_chart.includes_all is True assert dimension.dimension_chart.includes_unknown is True
def test_dept_user_should_be_able_to_delete_upload_from_shared_page( test_app_client, logged_in_dept_user): measure_version = MeasureVersionFactory( status="DRAFT", measure__shared_with=[logged_in_dept_user], uploads__guid="test-download", uploads__title="upload title", ) response = test_app_client.post( url_for( "cms.delete_upload", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, upload_guid="test-download", ), follow_redirects=True, ) assert response.status_code == 200 page = BeautifulSoup(response.data.decode("utf-8"), "html.parser") assert page.find("div", class_="eff-flash-message__body").get_text( strip=True) == "Deleted upload ‘upload title’" assert len(measure_version.uploads) == 0
def test_back_link_goes_to_measure_version_or_search_results_based_on_url_param( self, test_app_client, logged_in_rdu_user, from_search_query): measure_version = MeasureVersionFactory.create() url = f"{self.__measure_edit_url(measure_version)}/data-sources/new" if from_search_query: url += f"?from_search_query={from_search_query}" response = test_app_client.get(url) doc = html.fromstring(response.get_data(as_text=True)) back_links = doc.xpath("//a[text()='Back']") assert len(back_links) == 1 if from_search_query: expected_url = url_for( "cms.search_data_sources", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, q=from_search_query, ) else: expected_url = url_for( "cms.edit_measure_version", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, ) assert back_links[0].get("href") == expected_url
def test_only_allowed_users_can_see_copy_measure_button_on_edit_page( test_app_client, user_type, can_see_copy_button): user = UserFactory(user_type=user_type) measure_version = MeasureVersionFactory() with test_app_client.session_transaction() as session: session["user_id"] = user.id response = test_app_client.get( url_for( "cms.edit_measure_version", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, ), follow_redirects=True, ) page = BeautifulSoup(response.data.decode("utf-8"), "html.parser") page_button_texts = [ button.text.strip().lower() for button in page.find_all("button") ] assert ("create a copy of this measure" in page_button_texts) is can_see_copy_button
def test_dept_cannot_publish_a_shared_page(test_app_client, logged_in_dept_user): measure_version = MeasureVersionFactory( status="DEPARTMENT_REVIEW", measure__shared_with=[logged_in_dept_user]) response = test_app_client.get( url_for( "cms.edit_measure_version", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, )) assert response.status_code == 200 page = BeautifulSoup(response.data.decode("utf-8"), "html.parser") assert not page.find("button", id="send-to-approved") response = test_app_client.post( url_for( "cms.edit_measure_version", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, ), data=ImmutableMultiDict({"measure-action": "send-to-approved"}), follow_redirects=True, ) assert response.status_code == 403
def test_dept_user_should_be_able_to_edit_shared_page(test_app_client, logged_in_dept_user): measure_version = MeasureVersionFactory( status="DRAFT", measure__shared_with=[logged_in_dept_user], title="this will be updated") data = { "title": "this is the update", "db_version_id": measure_version.db_version_id + 1 } response = test_app_client.post( url_for( "cms.edit_measure_version", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, ), data=data, follow_redirects=True, ) assert response.status_code == 200 page = BeautifulSoup(response.data.decode("utf-8"), "html.parser") assert (page.find("div", class_="eff-flash-message__body").get_text( strip=True) == 'Updated page "this is the update"') assert measure_version.title == "this is the update"
def test_dept_user_should_not_be_able_to_edit_upload_if_page_not_shared( test_app_client, logged_in_dept_user, mock_edit_upload): measure_version = MeasureVersionFactory( status="DRAFT", uploads__guid="test-download", uploads__file_name="test-download.csv") response = test_app_client.get( url_for( "cms.edit_measure_version", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, )) assert response.status_code == 403 response = test_app_client.get( url_for( "cms.edit_upload", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, upload_guid="test-download", )) assert response.status_code == 403 mock_edit_upload.assert_not_called()
def test_returns_200_if_dept_user_has_access_to_measure( self, test_app_client, logged_in_dept_user): measure_version = MeasureVersionFactory.create( measure__shared_with=[logged_in_dept_user]) type_of_statistic = TypeOfStatisticFactory.create() organisation = OrganisationFactory.create() frequency_of_release = FrequencyOfReleaseFactory.create() url = self.__create_data_source_for_measure_url(measure_version) response = test_app_client.post( url, data={ "measure_version_id": measure_version.id, "title": "Test", "type_of_data": "ADMINISTRATIVE", "type_of_statistic_id": type_of_statistic.id, "publisher_id": organisation.id, "source_url": "https://www.gov.uk/statistics/testing", "frequency_of_release_id": frequency_of_release.id, "purpose": "Testing", }, ) assert response.status_code == 302
def test_admin_user_can_publish_page_in_dept_review(test_app_client, logged_in_admin_user, mock_request_build): measure_version = MeasureVersionFactory(title="Test Measure Page", status="DEPARTMENT_REVIEW", latest=False) response = test_app_client.post( url_for( "cms.edit_measure_version", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, ), data=ImmutableMultiDict({"measure-action": "send-to-approved"}), follow_redirects=True, ) assert response.status_code == 200 page = BeautifulSoup(response.data.decode("utf-8"), "html.parser") assert (page.find("div", class_="eff-flash-message__body").get_text( strip=True) == 'Sent page "Test Measure Page" to APPROVED') assert measure_version.status == "APPROVED" assert measure_version.last_updated_by == logged_in_admin_user.email assert measure_version.published_by == logged_in_admin_user.email assert measure_version.published_at == datetime.date.today() assert measure_version.latest is True mock_request_build.assert_called_once()
def test_post_with_an_updated_title_redirects_back_edit_data_source( self, test_app_client, logged_in_rdu_user): data_source = DataSourceFactory.create(title="Police stats 2019") measure_version = MeasureVersionFactory.create( data_sources=[data_source]) url = self.__update_data_source_url(data_source, measure_version) response = test_app_client.post( url, data={ "title": "Police statistics 2019", "type_of_data": "ADMINISTRATIVE", "type_of_statistic_id": data_source.type_of_statistic_id, "publisher_id": data_source.publisher_id, "source_url": data_source.source_url, "frequency_of_release_id": data_source.frequency_of_release_id, "purpose": data_source.purpose, }, ) # assert response.data.decode("utf-8") == "" assert response.status_code == 302 redirected_to_location = response.headers["Location"] match = re.search(f"{url}$", redirected_to_location) assert match, f"Expected {redirected_to_location} to match {url}" # Re-fetch the model from the database to be sure that it has been saved. data_source = DataSource.query.get(data_source.id) assert data_source.title == "Police statistics 2019", "Expected title to have been updated"
def test_measure_page_share_links_do_not_contain_double_slashes_between_domain_and_path( test_app_client, logged_in_rdu_user): measure_version = MeasureVersionFactory( status="DRAFT", measure__shared_with=[], measure__subtopics__topic__slug="topic", measure__subtopics__slug="subtopic", measure__slug="measure", measure__subtopics__topic__title="Test topic page", measure__subtopics__title="Test subtopic page", ) assert measure_version.measure.shared_with == [] assert logged_in_rdu_user.measures == [] resp = test_app_client.get( url_for( "static_site.measure_version", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, )) assert resp.status_code == 200 page = BeautifulSoup(resp.data.decode("utf-8"), "html.parser") share_links = page.find("div", {"class": "share"}).findChildren("a") for share_link in share_links: assert ( "https%3A//www.ethnicity-facts-figures.service.gov.uk/topic/subtopic/measure/latest" in share_link["href"])
def test_redirect_with_flash_if_measure_version_has_two_data_sources_already( self, test_app_client, logged_in_rdu_user, db): measure_version = MeasureVersionFactory() DataSourceFactory(measure_versions=[measure_version]) third_data_source = DataSourceFactory() res = test_app_client.post( url_for( "cms.link_existing_data_source", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, ), follow_redirects=False, data=ImmutableMultiDict( (("data_sources", third_data_source.id), )), ) assert parse.urlparse(res.location).path == url_for( "cms.edit_measure_version", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version=measure_version.version, ) redirected_response = test_app_client.get(res.location, follow_redirects=True) assert "Only two data sources can currently be linked to a measure version." in redirected_response.get_data( as_text=True)
def test_reorder_measures_triggers_build(test_app_client, logged_in_rdu_user): subtopic = SubtopicFactory() ids = [0, 1] reversed_ids = ids[::-1] for id_ in ids: MeasureVersionFactory(id=id_, measure__position=id_, measure__id=id_, measure__subtopics=[subtopic], measure__slug=str(id_)) builds = Build.query.all() assert len(builds) == 0 updates = [] for position, id in enumerate(reversed_ids): updates.append({ "position": position, "measure_id": str(id), "subtopic_id": subtopic.id }) response = test_app_client.post(url_for("cms.set_measure_order"), data=json.dumps({"positions": updates}), content_type="application/json") assert response.status_code == 200 builds = Build.query.all() assert len(builds) == 1
def test_create_new_version_of_page(self): measure_version = MeasureVersionFactory(latest=True) user = UserFactory(user_type=TypeOfUser.RDU_USER) assert measure_version.latest is True new_version = page_service.create_measure_version( measure_version, NewVersionType.MINOR_UPDATE, user=user) assert new_version.version == "1.1" assert new_version.status == "DRAFT" assert new_version.internal_edit_summary is None assert new_version.external_edit_summary is None assert new_version.published_at is None assert user.email == new_version.created_by assert new_version.latest is True assert new_version.get_previous_version().latest is False next_version = page_service.create_measure_version( measure_version, NewVersionType.MAJOR_UPDATE, user=user) assert next_version.get_previous_version().latest is False assert next_version.version == "2.0" assert next_version.status == "DRAFT" assert next_version.internal_edit_summary is None assert next_version.external_edit_summary is None assert next_version.published_at is None assert user.email == new_version.created_by assert next_version.latest is True
def test_create_copy_of_page(self): user = UserFactory(user_type=TypeOfUser.RDU_USER) measure_version = MeasureVersionFactory(latest=True, measure__slug="slug") assert measure_version.latest first_copy = page_service.create_measure_version( measure_version, NewVersionType.NEW_MEASURE, user=user) first_copy_measure_id = first_copy.measure_id first_copy_title = first_copy.title first_copy_slug = first_copy.measure.slug assert first_copy.version == "1.0" assert first_copy.status == "DRAFT" assert first_copy.internal_edit_summary is None assert first_copy.external_edit_summary is None assert first_copy.published_at is None assert first_copy.created_by == user.email assert first_copy.latest second_copy = page_service.create_measure_version( first_copy, NewVersionType.NEW_MEASURE, user=user) assert second_copy.version == "1.0" assert second_copy.status == "DRAFT" assert second_copy.internal_edit_summary is None assert second_copy.external_edit_summary is None assert second_copy.published_at is None assert user.email == first_copy.created_by assert second_copy.latest assert first_copy_measure_id != second_copy.measure_id assert second_copy.title == f"COPY OF {first_copy_title}" assert second_copy.measure.slug == f"{first_copy_slug}-copy"
def test_homepage_topics_display_in_rows_with_three_columns( number_of_topics, row_counts, test_app_client, logged_in_rdu_user): for i in range(number_of_topics): topic = TopicFactory(slug=f"topic-{i}", title=f"Test topic page #{i}", short_title=f"Testing #{i}") subtopic = SubtopicFactory(slug=f"subtopic-{i}", title=f"Test subtopic page #{i}", topic=topic) measure = MeasureFactory(slug=f"measure-{i}", subtopics=[subtopic]) MeasureVersionFactory(status="APPROVED", title=f"Test measure page #{i}", version="1.0", measure=measure) resp = test_app_client.get(url_for("static_site.index")) assert resp.status_code == 200 page = BeautifulSoup(resp.data.decode("utf-8"), "html.parser") topic_rows = page.select(".topic-row") assert len(topic_rows) == len(row_counts) for i, topic_row in enumerate(topic_rows): assert len(topic_rows[i].select(".topic")) == row_counts[i] for i in range(number_of_topics): assert page.select(".topic a")[i].text.strip() == f"Testing #{i}"
def test_update_measure_version_raises_if_page_not_editable(self): user = UserFactory(user_type=TypeOfUser.RDU_USER) measure_version = MeasureVersionFactory(version="1.0", status="DRAFT") measure_version_from_db = page_service.get_measure_version_by_measure_id_and_version( measure_version.measure.id, measure_version.version) assert measure_version_from_db.status == "DRAFT" page_service.update_measure_version( measure_version, measure_version_form=MeasureVersionForm( is_minor_update=True, title="Who cares", db_version_id=measure_version.db_version_id), data_source_forms=[], last_updated_by_email=user.email, **{"status": "APPROVED"}, ) measure_version_from_db = page_service.get_measure_version_by_measure_id_and_version( measure_version.measure.id, measure_version.version) assert measure_version_from_db.status == "APPROVED" with pytest.raises(PageUnEditable): page_service.update_measure_version( measure_version, measure_version_form=MeasureVersionForm( is_minor_update=True, title="I care too much!", db_version_id=measure_version.db_version_id), data_source_forms=[], last_updated_by_email=user.email, )
def test_latest_version_url_does_not_add_noindex_for_robots( test_app_client, logged_in_admin_user): # GIVEN the latest published version of a page with later draft created measure = MeasureFactory() measure_version = MeasureVersionFactory(measure=measure, status="APPROVED", latest=True, version="1.0") # WHEN we get the rendered template resp = test_app_client.get( url_for( "static_site.measure_version", topic_slug=measure_version.measure.subtopic.topic.slug, subtopic_slug=measure_version.measure.subtopic.slug, measure_slug=measure_version.measure.slug, version="latest", )) # THEN it should not contain a noindex tag assert resp.status_code == 200 page = BeautifulSoup(resp.data.decode("utf-8"), "html.parser") robots_tags = page.find_all( "meta", attrs={"name": "robots"}, content=lambda value: value and "noindex" in value) assert len(robots_tags) == 0
def test_data_corrections_page_shows_corrected_versions_with_link_to_page_containing_correction( test_app_client, logged_in_rdu_user, db_session): measure = MeasureFactory(slug="measure", subtopics__slug="subtopic", subtopics__topic__slug="topic") measure_versions = [] for version, published_at, update_corrects_data_mistake in ( ("1.0", datetime.fromisoformat("2000-01-01T12:00:00"), False), ("1.1", datetime.fromisoformat("2001-01-01T12:00:00"), True), ("1.2", datetime.fromisoformat("2002-01-01T12:00:00"), False), ("2.0", datetime.fromisoformat("2003-01-01T12:00:00"), False), ): measure_versions.append( MeasureVersionFactory( version=version, status="APPROVED", update_corrects_data_mistake=update_corrects_data_mistake, published_at=published_at, measure=measure, )) resp = test_app_client.get(url_for("static_site.corrections")) doc = html.fromstring(resp.get_data(as_text=True)) assert len(doc.xpath("//div[@class='corrected-measure-version']")) == 1 assert "1 January 2001" in doc.xpath( "//div[@class='corrected-measure-version']")[0].text_content() assert doc.xpath("//div[@class='corrected-measure-version']//h2/a/@href" )[0] == "/topic/subtopic/measure/1.1"