def test_new_barriers_since_notified_other_user(self):
"""
Changes made by other users should be included in new_barriers_since_notified
"""
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"])
user2 = create_test_user(sso_user_id=self.sso_user_data_2["user_id"])
saved_search = SavedSearch.objects.create(
user=user, name="Medium", filters={"priority": ["MEDIUM"]})
saved_search.mark_as_notified()
assert saved_search.new_barriers_since_notified.exists() is False
# Newly created barriers should be in the list
barrier4 = BarrierFactory(priority="MEDIUM")
barrier5 = BarrierFactory(priority="UNKNOWN")
saved_search = SavedSearch.objects.get(pk=saved_search.pk)
assert barrier4 in saved_search.new_barriers_since_notified
assert saved_search.new_barriers_since_notified.count() == 1
# Existing barriers should be in the list
barrier1.priority = BarrierPriority.objects.get(code="MEDIUM")
barrier1.modified_by = user2
barrier1.save()
saved_search = SavedSearch.objects.get(pk=saved_search.pk)
assert barrier1 in saved_search.new_barriers_since_notified
def test_change_owner__history_items(self):
user1 = create_test_user()
user2 = create_test_user()
barrier = BarrierFactory(created_by=user1)
TeamMemberFactory(barrier=barrier,
user=user1,
role="Reporter",
default=True)
member = TeamMemberFactory(barrier=barrier,
user=user1,
role="Owner",
default=True)
url = reverse("get-member", kwargs={"pk": member.id})
assert user1 == member.user
items = TeamMemberHistoryFactory.get_history_items(
barrier_id=barrier.pk)
assert 2 == len(items)
payload = {"user": user2.profile.sso_user_id}
response = self.api_client.patch(url, format="json", data=payload)
assert status.HTTP_200_OK == response.status_code
items = TeamMemberHistoryFactory.get_history_items(
barrier_id=barrier.pk)
assert 3 == len(items)
assert user1 == items[-1].old_record.user
assert user2 == items[-1].new_record.user
assert "Owner" == items[-1].old_record.role
assert "Owner" == items[-1].new_record.role
def setUp(self):
super().setUp()
self.barrier = BarrierFactory()
self.user1 = create_test_user(
sso_user_id=self.sso_user_data_1["user_id"])
self.user2 = create_test_user(
sso_user_id=self.sso_user_data_2["user_id"])
self.api_client1 = self.create_api_client(user=self.user1)
self.api_client2 = self.create_api_client(user=self.user2)
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_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_change_contributor_forbidden(self):
user1 = create_test_user()
user2 = create_test_user()
barrier = BarrierFactory(created_by=user1)
member = TeamMemberFactory(barrier=barrier, user=user1, role="Contributor")
url = reverse("get-member", kwargs={"pk": member.id})
assert user1 == member.user
payload = {"user": user2.id}
response = self.api_client.patch(url, format="json", data=payload)
assert status.HTTP_403_FORBIDDEN == response.status_code
member.refresh_from_db()
assert user1 == member.user
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_user_country(self):
"""Test user's country"""
user_test = create_test_user(
location="ba6ee1ca-5d95-e211-a939-e4115bead28a")
api_client = self.create_api_client(user=user_test)
url = reverse("who_am_i")
response = api_client.get(url)
assert response.status_code == status.HTTP_200_OK
response_data = response.json()
assert response_data == {
"id": user_test.id,
"username": user_test.username,
"last_login": None,
"first_name": user_test.first_name,
"last_name": user_test.last_name,
"email": user_test.email,
"location": "ba6ee1ca-5d95-e211-a939-e4115bead28a",
"internal": False,
"permitted_applications": None,
"user_profile": None,
}
def test_mark_as_seen(self):
"""
Calling mark_as_seen should reset updated and new barrier ids
"""
barrier1 = BarrierFactory(priority="LOW")
barrier2 = BarrierFactory(priority="MEDIUM")
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 == []
assert saved_search.updated_barrier_ids == []
barrier1.priority = BarrierPriority.objects.get(code="MEDIUM")
barrier1.save()
barrier2.summary = "New summary"
barrier2.save()
saved_search = SavedSearch.objects.get(pk=saved_search.pk)
assert saved_search.new_barrier_ids == [barrier1.pk]
assert barrier1 in saved_search.new_barriers_since_notified
assert barrier1 not in saved_search.updated_barriers_since_notified
assert barrier2 not in saved_search.new_barriers_since_notified
assert barrier2 in saved_search.updated_barriers_since_notified
saved_search = SavedSearch.objects.get(pk=saved_search.pk)
saved_search.mark_as_seen()
assert saved_search.new_barrier_ids == []
assert saved_search.updated_barrier_ids == []
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_new_barrier_ids_other_user(self):
"""
Changes made by other users should 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 == []
# Newly created barriers should be in the list
barrier4 = BarrierFactory(priority="MEDIUM")
barrier5 = BarrierFactory(priority="UNKNOWN")
saved_search = SavedSearch.objects.get(pk=saved_search.pk)
assert saved_search.new_barrier_ids == [barrier4.id]
# Existing barriers should be in the list
barrier1.priority = BarrierPriority.objects.get(code="MEDIUM")
barrier1.save()
saved_search = SavedSearch.objects.get(pk=saved_search.pk)
assert barrier1.pk in saved_search.new_barrier_ids
def __create_user(
self,
role=None,
is_superuser=False,
is_staff=False,
):
"""
Creates a user for testing purposes.
:param role: Role based user group.
:return: User object
"""
user_kwargs = {
"is_superuser": is_superuser,
"is_staff": is_staff,
}
user = create_test_user(**user_kwargs)
if role:
try:
role_group = Group.objects.get(name=role)
user.groups.add(role_group)
except Group.DoesNotExist:
pass
return user
def test_updated_barriers_since_notified_other_user(self):
"""
Changes made by the other users should be included in updated_barriers_since_notified
"""
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_notified()
assert saved_search.updated_barriers_since_notified.exists() is False
barrier1.summary = "New summary"
barrier1.save()
barrier2.summary = "New summary"
barrier2.save()
saved_search = SavedSearch.objects.get(pk=saved_search.pk)
assert barrier2 in saved_search.updated_barriers_since_notified
assert saved_search.updated_barriers_since_notified.count() == 1
def test_filter_barriers_my_barriers(self):
BarrierFactory()
_user1 = create_test_user(sso_user_id=self.sso_user_data_1["user_id"])
_barrier1 = BarrierFactory()
user2 = create_test_user(sso_user_id=self.sso_creator["user_id"])
barrier2 = BarrierFactory(created_by=user2)
assert 3 == Barrier.objects.count()
url = f'{reverse("list-barriers")}?user={user2.id}'
client = self.create_api_client(user=user2)
response = client.get(url)
assert status.HTTP_200_OK == response.status_code
assert 1 == response.data["count"]
assert str(barrier2.id) == response.data["results"][0]["id"]
def test_user_internal(self):
"""Test user's internal flag"""
user_test = create_test_user(internal=True)
api_client = self.create_api_client(user=user_test)
url = reverse("who_am_i")
response = api_client.get(url)
assert response.status_code == status.HTTP_200_OK
response_data = response.json()
assert response_data == {
"id": user_test.id,
"username": user_test.username,
"last_login": None,
"first_name": user_test.first_name,
"last_name": user_test.last_name,
"email": user_test.email,
"location": None,
"internal": True,
"permitted_applications": None,
"user_profile": None,
}
def test_initial_notify_state(self):
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"]})
assert saved_search.notify_about_additions is True
assert saved_search.notify_about_updates is True
def test_change_owner(self):
user1 = create_test_user()
user2 = create_test_user()
barrier = BarrierFactory(created_by=user1)
TeamMemberFactory(barrier=barrier, user=user1, role="Reporter", default=True)
member = TeamMemberFactory(
barrier=barrier, user=user1, role="Owner", default=True
)
url = reverse("get-member", kwargs={"pk": member.id})
assert user1 == member.user
payload = {"user": user2.profile.sso_user_id}
response = self.api_client.patch(url, format="json", data=payload)
assert status.HTTP_200_OK == response.status_code
member.refresh_from_db()
assert user2 == member.user
def test_badly_formatted_usr(self):
self.user1 = create_test_user()
self.user1.username = self.user1.email
self.user1.profile.sso_user_id = None
self.user1.save()
call_command("fix_all_users_for_sso_system")
assert UserModel.objects.filter(id=self.user1.id).exists() is False
def test_bad_sso_userid(self):
mock_user = create_test_user()
self.create_data_records(mock_user)
self.check_count_on_all_objects(mock_user, 1)
call_command("fix_all_users_for_sso_system")
# The bad user has been deleted
assert UserModel.objects.filter(id=mock_user.id).exists() is False
def test_delivery_confidence_in_response(self):
user = create_test_user(sso_user_id=self.sso_creator["user_id"])
barrier: Barrier = BarrierFactory()
barrier_progress_update_on_track = BarrierProgressUpdate.objects.create(
barrier=barrier,
status=PROGRESS_UPDATE_CHOICES.ON_TRACK,
created_by=user)
barrier.progress_updates.add(barrier_progress_update_on_track)
serialised_data = BarrierCsvExportSerializer(barrier).data
assert "delivery_confidence" in serialised_data.keys()
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_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_multipe_current_good_user(self):
# First build mock data
self.user1 = create_test_user()
self.user2 = create_test_user()
self.user1.profile.sso_email_user_id = None
self.user1.save()
self.user2.profile.sso_email_user_id = None
self.user2.profile.sso_user_id = self.user1.profile.sso_user_id
self.user2.save()
# User mock data in mock SSO calls
self._add_user_to_mockdb(self.user1)
self._add_user_to_mockdb(self.user2)
call_command("fix_all_users_for_sso_system")
assert UserModel.objects.filter(id=self.user2.id).exists() is False
self.user1.refresh_from_db()
assert self.user1.profile.sso_email_user_id is not None
assert self.user1.profile.sso_email_user_id == self.user1.username
def test_delete_member(self):
user1 = create_test_user()
barrier = BarrierFactory(created_by=user1)
member = TeamMemberFactory(barrier=barrier, user=user1, role="Contributor")
url = reverse("get-member", kwargs={"pk": member.id})
assert 1 == TeamMember.objects.filter(barrier=barrier).count()
response = self.api_client.delete(url)
assert response.status_code == status.HTTP_204_NO_CONTENT
assert 0 == TeamMember.objects.filter(barrier=barrier).count()
def test_no_members_except_default(self, mock_creator):
"""Test there are no barrier members using list"""
user = create_test_user(sso_user_id=self.sso_user_data_1["user_id"])
barrier = BarrierFactory(created_by=user)
TeamMember.objects.create(barrier=barrier, user=user, role="wobble")
mock_creator.return_value = self.sso_creator
members_url = reverse("list-members", kwargs={"pk": barrier.id})
client = self.create_api_client(user=user)
response = client.get(members_url)
assert response.status_code == status.HTTP_200_OK
assert 1 == response.data["count"]
def test_barriers(self):
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"]})
assert barrier1 not in saved_search.barriers
assert barrier2 in saved_search.barriers
assert barrier3 not in saved_search.barriers
def test_update_good_current_user_to_new_user(self):
# First build mock data
self.user1 = create_test_user()
self.user2 = create_test_user()
self.user3 = create_test_user()
# User mock data in mock SSO calls
self._add_user_to_mockdb(self.user1)
self._add_user_to_mockdb(self.user2)
self._add_user_to_mockdb(self.user3)
assert self.user1.profile.sso_email_user_id != self.user1.username
assert self.user2.profile.sso_email_user_id != self.user2.username
assert self.user2.profile.sso_email_user_id != self.user3.username
# Model current good user objects. they have the user_id GUID but not the email_user_id
self.user1.profile.sso_email_user_id = None
self.user1.save()
self.user2.profile.sso_email_user_id = None
self.user2.save()
self.user3.profile.sso_email_user_id = None
self.user3.save()
assert self.user1.profile.sso_email_user_id is None
assert self.user2.profile.sso_email_user_id is None
assert self.user3.profile.sso_email_user_id is None
call_command("fix_all_users_for_sso_system")
# Refresh the ORM objects to show that the sso_email_user_id values have been set.
self.user1.refresh_from_db()
self.user2.refresh_from_db()
self.user3.refresh_from_db()
assert self.user1.profile.sso_email_user_id is not None
assert self.user2.profile.sso_email_user_id is not None
assert self.user3.profile.sso_email_user_id is not None
assert self.user1.profile.sso_email_user_id == self.user1.username
assert self.user2.profile.sso_email_user_id == self.user2.username
assert self.user3.profile.sso_email_user_id == self.user3.username
def test_include_archived_barriers(self):
user = create_test_user()
barrier = BarrierFactory()
assert 1 == Barrier.objects.count()
response = self.api_client.get(self.url)
assert status.HTTP_200_OK == response.status_code
assert 1 == response.data["count"]
barrier.archive(user=user)
response = self.api_client.get(self.url)
assert status.HTTP_200_OK == response.status_code
assert 1 == response.data["count"]
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_list_barrier_without_archived_barriers(self):
url = f"{self.url}?archived=0"
user = create_test_user()
barrier = BarrierFactory()
assert 1 == Barrier.objects.count()
response = self.api_client.get(url)
assert status.HTTP_200_OK == response.status_code
assert 1 == response.data["count"]
barrier.archive(user=user)
response = self.api_client.get(url)
assert status.HTTP_200_OK == response.status_code
assert 0 == response.data["count"]
