def test_list_reports_are_ordered_by_created_on(self):
user = create_test_user(sso_user_id=self.sso_creator["user_id"])
r1 = ReportFactory(
created_on=datetime(2020, 1, 1, tzinfo=UTC),
created_by=user
)
r2 = ReportFactory(
created_on=datetime(2020, 2, 2, tzinfo=UTC),
created_by=user
)
r3 = ReportFactory(
created_on=datetime(2020, 3, 3, tzinfo=UTC),
created_by=user
)
order_by = "created_on"
url = f'{reverse("list-reports")}?order_by={order_by}'
client = self.create_api_client(user=user)
response = client.get(url)
assert status.HTTP_200_OK == response.status_code
reports = Barrier.reports.all().order_by(order_by)
assert reports.count() == response.data["count"]
report_ids = [b["id"] for b in response.data["results"]]
db_report_ids = [str(b.id) for b in reports]
assert db_report_ids == report_ids
def test_reported_as_resolved_in_full(self):
resolved_in_full = 4
report = ReportFactory(status=resolved_in_full,
status_date="2020-02-02",
status_summary="wibble")
report.submit_report()
barrier = Barrier.objects.get(id=report.id)
assert resolved_in_full == barrier.status
def test_submit_report_as_half_baked_user(self):
user1 = create_test_user(first_name="",
last_name="",
email="*****@*****.**",
username="")
user2 = create_test_user(first_name="",
last_name="",
email="",
username="******")
user3 = create_test_user(first_name="",
last_name="",
email="",
username="******")
user4 = create_test_user(first_name="",
last_name="",
email="*****@*****.**",
username="******")
test_parameters = [
{
"user": user1,
"expected_modified_user": "******"
},
{
"user": user2,
"expected_modified_user": "******"
},
{
"user": user3,
"expected_modified_user": "******"
},
{
"user": user4,
"expected_modified_user": "******"
},
]
for tp in test_parameters:
with self.subTest(tp=tp):
report = ReportFactory()
url = reverse("submit-report", kwargs={"pk": report.id})
self.client.force_authenticate(user=tp["user"])
submit_response = self.client.put(url, format="json", data={})
assert submit_response.status_code == status.HTTP_200_OK
report.refresh_from_db()
assert not report.draft
assert tp["user"] == report.modified_by
assert tp["user"].id == report.modified_by_id
assert "2020-02-22" == report.modified_on.strftime("%Y-%m-%d")
assert tp["expected_modified_user"] == report.modified_user
def test_cannot_see_archived_reports(self):
user = create_test_user(
first_name="", last_name="", email="*****@*****.**", username=""
)
report = ReportFactory(created_by=user)
client = self.create_api_client(user=user)
response = client.get(self.url)
assert status.HTTP_200_OK == response.status_code
assert 1 == response.data["count"]
report.archive(user=user, reason="it wobbles!")
response = client.get(self.url)
assert status.HTTP_200_OK == response.status_code
assert 0 == response.data["count"]
def test_new_barrier_ids_current_user(self):
"""
Changes made by the current user should not be included in new_barrier_ids
"""
barrier1 = BarrierFactory(priority="LOW")
barrier2 = BarrierFactory(priority="MEDIUM")
barrier3 = BarrierFactory(priority="HIGH")
user = create_test_user(sso_user_id=self.sso_user_data_1["user_id"])
saved_search = SavedSearch.objects.create(
user=user, name="Medium", filters={"priority": ["MEDIUM"]})
saved_search.mark_as_seen()
assert saved_search.new_barrier_ids == []
# Barriers created by current user should be ignored
api_client = self.create_api_client(user=user)
report = ReportFactory(priority="MEDIUM", created_by=user)
submit_url = reverse("submit-report", kwargs={"pk": report.id})
response = api_client.put(submit_url)
assert status.HTTP_200_OK == response.status_code
saved_search = SavedSearch.objects.get(pk=saved_search.pk)
assert report.pk not in saved_search.new_barrier_ids
assert saved_search.new_barrier_ids == []
# Barriers changed by current user should be ignored
barrier1.priority = BarrierPriority.objects.get(code="MEDIUM")
barrier1.modified_by = user
barrier1.save()
saved_search = SavedSearch.objects.get(pk=saved_search.pk)
assert barrier1.pk not in saved_search.new_barrier_ids
assert saved_search.new_barrier_ids == []
def test_list_barriers_exclude_reports(self):
"""
Draft barriers (reports) should be excluded.
"""
_report = ReportFactory()
response = self.api_client.get(self.url)
assert status.HTTP_200_OK == response.status_code
assert 0 == response.data["count"]
def test_submit_report_without_all_sectors_and_sectors(self):
report = ReportFactory(sectors=[], sectors_affected=True)
assert not report.sectors
url = reverse("submit-report", kwargs={"pk": report.id})
submit_response = self.api_client.put(url, format="json", data={})
assert submit_response.status_code == status.HTTP_400_BAD_REQUEST
def test_delete_request_archives_report(self):
creator = create_test_user(sso_user_id=self.sso_creator["user_id"])
report = ReportFactory(created_by=creator)
client = self.create_api_client(user=creator)
url = reverse("get-report", kwargs={"pk": report.id})
assert 1 == Barrier.objects.count()
response = client.delete(url)
assert status.HTTP_204_NO_CONTENT == response.status_code
report.refresh_from_db()
assert 1 == Barrier.objects.count()
assert report.archive, "Expected True."
assert creator == report.archived_by
assert "2020-02-02" == report.archived_on.strftime('%Y-%m-%d')
assert not report.archived_explanation
assert not report.archived_reason
def test_no_interaction_is_created_when_submit_report_fails(self):
report = ReportFactory(term=None)
assert not Interaction.objects.filter(barrier=report)
submit_url = reverse("submit-report", kwargs={"pk": report.id})
response = self.api_client.put(submit_url)
assert status.HTTP_400_BAD_REQUEST == response.status_code
assert not Interaction.objects.filter(barrier=report)
def test_submit_report_creates_an_interaction(self):
report = ReportFactory()
assert not Interaction.objects.filter(barrier=report)
submit_url = reverse("submit-report", kwargs={"pk": report.id})
response = self.api_client.put(submit_url)
assert status.HTTP_200_OK == response.status_code
assert 1 == Interaction.objects.filter(barrier=report).count()
def test_list_reports__can_only_see_own_reports(self):
"""
List reports should only return reports that were created by the requesting user.
"""
user = create_test_user(
first_name="", last_name="", email="*****@*****.**", username=""
)
report = ReportFactory(created_by=user)
client = self.create_api_client(user=user)
_another_user = create_test_user()
_another_report = ReportFactory(created_by=_another_user)
assert 2 == Barrier.objects.count()
response = client.get(self.url)
assert status.HTTP_200_OK == response.status_code
assert 1 == response.data["count"]
assert str(report.id) == response.data["results"][0]["id"]
def test_barrier_count_showing_count_for_all_and_user_report(self):
"""
Users will see how many reports have been submitted and also how many they've submitted themselves.
In this case 1 was submitted by the user.
"""
ReportFactory()
creator = create_test_user(sso_user_id=self.sso_creator["user_id"])
ReportFactory(created_by=creator)
client = self.create_api_client(user=creator)
url = reverse("barrier-count")
response = client.get(url)
assert status.HTTP_200_OK == response.status_code
assert 0 == response.data["barriers"]["total"]
assert 0 == response.data["barriers"]["open"]
assert 0 == response.data["barriers"]["resolved"]
assert 2 == response.data["reports"]
assert 0 == response.data["user"]["barriers"]
assert 1 == response.data["user"]["reports"]
def test_report_can_only_be_deleted_by_its_creator(self):
creator = create_test_user(sso_user_id=self.sso_creator["user_id"])
report = ReportFactory(created_by=creator)
user1 = create_test_user(sso_user_id=self.sso_user_data_1["user_id"])
url = reverse("get-report", kwargs={"pk": report.id})
client = self.create_api_client(user=user1)
assert 1 == Barrier.objects.count()
response = client.delete(url)
assert status.HTTP_403_FORBIDDEN == response.status_code
assert 1 == Barrier.objects.count()
def test_list_reports__cannot_see_others_reports(self):
"""
Users are only allowed to see their own draft barriers.
"""
creator = create_test_user(sso_user_id=self.sso_creator["user_id"])
ReportFactory(
created_on=datetime(2020, 1, 1, tzinfo=UTC),
created_by=creator
)
user1 = create_test_user(sso_user_id=self.sso_user_data_1["user_id"])
assert 1 == Barrier.objects.count()
url = f'{reverse("list-reports")}'
client = self.create_api_client(user=user1)
response = client.get(url)
assert status.HTTP_200_OK == response.status_code
assert 0 == response.data["count"]
def test_submit_report_creates_default_members(self):
"""
When a user submits the report the user should be added as reporter and owner as well.
The members are reverse ordered by their role in the response.
"""
reporter = "Reporter"
owner = "Owner"
user = create_test_user(
first_name="Marty",
last_name="Bloggs",
email="*****@*****.**",
username="******",
)
api_client = self.create_api_client(user=user)
report = ReportFactory(created_by=user)
members_url = reverse("list-members", kwargs={"pk": report.id})
submit_url = reverse("submit-report", kwargs={"pk": report.id})
response = api_client.get(members_url)
assert status.HTTP_200_OK == response.status_code
assert 0 == response.data["count"]
response = api_client.put(submit_url)
assert status.HTTP_200_OK == response.status_code
response = api_client.get(members_url)
assert status.HTTP_200_OK == response.status_code
assert 2 == response.data["count"]
# Assert Reporter
member = response.data["results"][0]
assert user.email == member["user"]["email"]
assert user.first_name == member["user"]["first_name"]
assert user.last_name == member["user"]["last_name"]
assert reporter == member["role"]
# Assert Owner
member = response.data["results"][1]
assert user.email == member["user"]["email"]
assert user.first_name == member["user"]["first_name"]
assert user.last_name == member["user"]["last_name"]
assert owner == member["role"]
def test_report_gets_reference_code_generated(self):
report = ReportFactory()
assert report.code not in ("", None)
def setUp(self):
super().setUp()
self.report = ReportFactory()
self.url = reverse("get-report", kwargs={"pk": self.report.id})
class TestReportTags(APITestMixin, TestCase):
def setUp(self):
super().setUp()
self.report = ReportFactory()
self.url = reverse("get-report", kwargs={"pk": self.report.id})
def test_get_report_without_tags(self):
response = self.api_client.get(self.url)
assert status.HTTP_200_OK == response.status_code
assert 0 == len(response.data["tags"])
def test_get_report_with_tags(self):
tag_title = "wobble"
tag = BarrierTagFactory(title=tag_title)
self.report.tags.add(tag)
response = self.api_client.get(self.url)
assert status.HTTP_200_OK == response.status_code
assert 1 == len(response.data["tags"])
assert tag_title == response.data["tags"][0]["title"]
def test_patch_report_with_valid_tags(self):
tag_title = "wobble"
tag = BarrierTagFactory(title=tag_title)
assert not self.report.tags.exists(), "Expected no tags to start with."
payload = {"tags": [tag.id]}
response = self.api_client.patch(self.url, format="json", data=payload)
assert status.HTTP_200_OK == response.status_code
self.report.refresh_from_db()
assert 1 == self.report.tags.count()
assert tag.id == self.report.tags.first().id
def test_patch_report_with_nonexisting_tags(self):
assert not self.report.tags.exists(), "Expected no tags to start with."
payload = {"tags": [123321]}
response = self.api_client.patch(self.url, format="json", data=payload)
assert status.HTTP_200_OK == response.status_code
self.report.refresh_from_db()
assert not self.report.tags.exists(
), "Expected no tags to be assigned."
def test_patch_report_swapping_tags(self):
# existing tag
tag01_title = "wobble"
tag01 = BarrierTagFactory(title=tag01_title)
self.report.tags.add(tag01)
# the tag we want to switch to
tag02_title = "wibble"
tag02 = BarrierTagFactory(title=tag02_title)
assert (1 == self.report.tags.count()
), f"Expected only 1 tag, got {self.report.tags.count()}"
assert tag01.id == self.report.tags.first().id
payload = {"tags": [tag02.id]}
response = self.api_client.patch(self.url, format="json", data=payload)
assert status.HTTP_200_OK == response.status_code
assert (1 == self.report.tags.count()
), f"Expected only 1 tag, got {self.report.tags.count()}"
assert tag02.id == self.report.tags.first().id
def test_patch_report_extending_tags(self):
# existing tag
tag01_title = "wobble"
tag01 = BarrierTagFactory(title=tag01_title)
self.report.tags.add(tag01)
# tag to be added
tag02_title = "wibble"
tag02 = BarrierTagFactory(title=tag02_title)
assert (1 == self.report.tags.count()
), f"Expected only 1 tag, got {self.report.tags.count()}"
assert tag01.id == self.report.tags.first().id
payload = {"tags": (tag01.id, tag02.id)}
response = self.api_client.patch(self.url, format="json", data=payload)
assert status.HTTP_200_OK == response.status_code
assert (2 == self.report.tags.count()
), f"Expected only 2 tags, got {self.report.tags.count()}"
tag_ids = list(self.report.tags.values_list("id", flat=True))
assert {tag01.id, tag02.id} == set(tag_ids)
def test_patch_report_remove_all_tags(self):
# existing tags
tags = BarrierTagFactory.create_batch(2)
self.report.tags.add(*tags)
assert (2 == self.report.tags.count()
), f"Expected only 2 tags, got {self.report.tags.count()}"
payload = {"tags": []}
response = self.api_client.patch(self.url, format="json", data=payload)
assert status.HTTP_200_OK == response.status_code
tags_count = self.report.tags.count()
assert 0 == tags_count, f"Expected 0 tags, got {tags_count}."
def test_patch_report_with_invalid_tags_returns_400(self):
assert not self.report.tags.exists(), "Expected no tags to start with."
invalid_payloads = [123, "wobble", {"also": "invalid"}]
for case in invalid_payloads:
with self.subTest(case=case):
payload = {"tags": case}
response = self.api_client.patch(self.url,
format="json",
data=payload)
assert status.HTTP_400_BAD_REQUEST == response.status_code
self.report.refresh_from_db()
assert not self.report.tags.exists(
), "Expected no tags to be added."
