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"
