def test_new_comment_email_sent_to_crew_default_endpoint(self):
# Setup data - Create a Request, add Crew members and Responsible
crew_member1 = create_user(is_staff=True)
crew_member2 = create_user(is_staff=True)
responsible = create_user(is_staff=True)
request = create_request(100,
self.normal_user,
responsible=responsible)
create_crew(200, request, crew_member1, "Cameraman")
create_crew(201, request, crew_member2, "Reporter")
# New comment data
data = {
"text": "New comment",
}
# Authorized staff user and create new comment
self.authorize_user(self.normal_user)
response = self.client.post(f"/api/v1/requests/{request.id}/comments",
data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Check if e-mail was sent to the right people
self.assertEqual(len(mail.outbox), 1)
self.assertNotIn(self.normal_user.email, mail.outbox[0].to)
self.assertNotIn(self.normal_user.email, mail.outbox[0].cc)
self.assertNotIn(self.normal_user.email, mail.outbox[0].bcc)
self.assertIn(crew_member1.email, mail.outbox[0].to)
self.assertIn(crew_member2.email, mail.outbox[0].to)
self.assertIn(responsible.email, mail.outbox[0].cc)
self.assertIn(self.editor_in_chief.email, mail.outbox[0].cc)
self.assertEqual(mail.outbox[0].subject,
f"{request.title} | Hozzászólás érkezett")
def setUp(self):
# Create normal user
self.normal_user = create_user()
# Create staff user
self.staff_user = create_user(is_staff=True)
# Create staff user
self.admin_user = create_user(is_admin=True)
def setUp(self):
# Create normal user
self.normal_user = create_user()
# Create staff user
self.staff_user = create_user(is_staff=True)
# Create special users
self.editor_in_chief = create_user(is_staff=True,
groups=["FOSZERKESZTO"])
self.production_manager = create_user(is_staff=True,
groups=["GYARTASVEZETO"])
self.pr_responsible = create_user(is_staff=True, groups=["PR"])
def test_ban_unban_edge_cases(self):
user = create_user()
self.authorize_user(self.admin)
# Call ban multiple times
response = self.client.post(f"{self.url}/{user.id}/ban")
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.check_if_user_is_banned(user.id, True)
response = self.client.post(f"{self.url}/{user.id}/ban")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(str(response.data["receiver"][0]),
"Ban with this Receiver already exists.")
self.check_if_user_is_banned(user.id, True)
# Call unban multiple times
response = self.client.delete(f"{self.url}/{user.id}/ban")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.check_if_user_is_banned(user.id, False)
response = self.client.delete(f"{self.url}/{user.id}/ban")
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.check_if_user_is_banned(user.id, False)
# Try to ban himself
response = self.client.post(f"{self.url}/{self.admin.id}/ban")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(str(response.data["receiver"][0]),
"Users cannot ban themselves.")
def setUp(self):
user = create_user()
self.request = create_request(100, user)
self.crew_member = create_crew(200, self.request, user, "Test")
self.video = create_video(300, self.request)
self.comment = create_comment(400, self.request, user, False)
self.rating = create_rating(500, self.video, user)
def test_sentinel_user_on_user_delete(self):
user = create_user()
request = create_request(100, user, responsible=user)
video = create_video(200, request, editor=user)
create_crew(300, request, user, "Test")
create_comment(400, request, user, False)
create_rating(500, video, user)
request.refresh_from_db()
self.assertEqual(request.requester, user)
self.assertEqual(request.responsible, user)
self.assertEqual(request.videos.get().editor, user)
self.assertEqual(request.crew.get().member, user)
self.assertEqual(request.comments.get().author, user)
self.assertEqual(request.videos.get().ratings.get().author, user)
user.delete()
request.refresh_from_db()
sentinel_user = get_sentinel_user()
self.assertEqual(request.requester, sentinel_user)
self.assertEqual(request.responsible, sentinel_user)
self.assertEqual(request.videos.get().editor, sentinel_user)
self.assertFalse(request.crew.exists())
self.assertEqual(request.comments.get().author, sentinel_user)
self.assertEqual(request.videos.get().ratings.get().author,
sentinel_user)
def test_external_request_retrieve_fail(self):
response = self.client.get(f"{self.url}/{INVALID_ID}")
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
user = create_user()
request = create_request(100, user, requested_by=user)
response = self.client.get(f"{self.url}/{request.id}")
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def setUp(self):
self.url = "/api/v1/external/sch-events/requests"
self.admin_url = "/api/v1/admin/requests"
self.default_url = "/api/v1/requests"
self.user = create_user(password="******",
groups=["Service Accounts"])
token = Token.objects.get_or_create(user=self.user)[0]
self.client.credentials(HTTP_AUTHORIZATION=f"Token {token}")
def test_external_comment_creation_fail(self):
data = self._create_comment_test_data
response = self.client.post(f"{self.url}/{INVALID_ID}/comments", data)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
user = create_user()
request = create_request(100, user, requested_by=user)
response = self.client.post(f"{self.url}/{request.id}/comments", data)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_external_comment_creation_success(self):
data = self._create_comment_test_data
user = create_user()
request = create_request(100, user, requested_by=self.user)
response = self.client.post(f"{self.url}/{request.id}/comments", data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
req = Request.objects.get(pk=request.id)
self.assertEqual(req.comments.all()[0].author, self.user)
self.assertEqual(req.comments.all()[0].text, data["text"])
def test_external_request_creation_unusable_for_other_users(self):
data = self._create_request_test_data
admin_user = create_user(is_admin=True)
self.authorize_user(admin_user)
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
staff_user = create_user(is_staff=True)
self.authorize_user(staff_user)
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
user = create_user()
self.authorize_user(user)
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.client.credentials()
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
def test_external_request_retrieve_unusable_for_other_users(self):
user = create_user()
request = create_request(100, user, requested_by=self.user)
admin_user = create_user(is_admin=True)
self.authorize_user(admin_user)
response = self.client.get(f"{self.url}/{request.id}")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
staff_user = create_user(is_staff=True)
self.authorize_user(staff_user)
response = self.client.get(f"{self.url}/{request.id}")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.authorize_user(user)
response = self.client.get(f"{self.url}/{request.id}")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.client.credentials()
response = self.client.get(f"{self.url}/{request.id}")
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
def test_new_comment_email_sent_to_user_and_crew_admin_endpoint_non_internal(
self):
# Setup data - Create a Request, add Crew members and Responsible
crew_member1 = create_user(is_staff=True)
crew_member2 = create_user(is_staff=True)
responsible = create_user(is_staff=True)
request = create_request(100,
self.normal_user,
responsible=responsible)
create_crew(200, request, crew_member1, "Cameraman")
create_crew(201, request, crew_member2, "Reporter")
# New comment data
data = {
"text":
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut ut ex erat. Nunc rutrum ac odio nec accumsan. Integer tristique nibh mollis nunc rhoncus, at dictum dui pellentesque. Integer ut tortor libero. Maecenas nec sollicitudin neque, a laoreet quam. Duis eu enim enim. Vestibulum porta commodo dictum.\nSuspendisse condimentum, nisl ut elementum mattis, felis mauris dictum enim, at viverra elit felis eget elit. Nam finibus quis neque id varius. Aenean vel metus et ipsum feugiat consectetur nec at elit. In malesuada scelerisque quam ac blandit. Donec venenatis aliquam ex ac dignissim. Pellentesque eleifend tortor a purus egestas, eget pretium mi egestas. Sed non neque maximus, iaculis ex at, egestas augue. Maecenas non enim eu libero facilisis cursus at sed quam. Duis at tortor sapien. Duis congue turpis libero, ut dapibus eros efficitur vel. Curabitur aliquam eros eget gravida congue. Donec et libero egestas, hendrerit elit sed, fermentum sapien. Nunc placerat tempor metus vel efficitur. In eget tortor id est mattis blandit vitae vel mi. Integer aliquet at odio ac dictum.\nUt eros nibh, tincidunt sit amet felis vitae, vehicula posuere diam. Nunc a aliquam enim, eget scelerisque lectus. Maecenas et risus in leo luctus sodales eu venenatis mauris. Vivamus quis metus finibus, vehicula tellus nec, placerat tortor. Quisque vel felis auctor, scelerisque massa sit amet, gravida ex. Phasellus orci dolor, faucibus placerat purus nec, iaculis faucibus tortor. Aenean fringilla justo a metus placerat, ut volutpat quam scelerisque. Ut laoreet ullamcorper quam. Aenean sed sodales sem. Nulla dolor tortor, sagittis quis dui non, dapibus hendrerit ligula. Fusce consectetur sapien arcu. Nunc accumsan leo et turpis convallis sagittis. Sed tincidunt nunc ut vehicula cursus. Sed facilisis tortor ac ex dapibus interdum.",
"internal": False,
}
# Authorized staff user and create new comment
self.authorize_user(self.staff_user)
response = self.client.post(
f"/api/v1/admin/requests/{request.id}/comments", data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Check if e-mail was sent to the right people
self.assertEqual(len(mail.outbox), 2)
# User e-mail
self.assertIn(self.normal_user.email, mail.outbox[0].to)
self.assertIn(settings.DEFAULT_REPLY_EMAIL, mail.outbox[0].reply_to)
self.assertEqual(mail.outbox[0].subject,
f"{request.title} | Hozzászólás érkezett")
# Crew e-mail
self.assertIn(crew_member1.email, mail.outbox[1].to)
self.assertIn(crew_member2.email, mail.outbox[1].to)
self.assertIn(responsible.email, mail.outbox[1].cc)
self.assertIn(self.editor_in_chief.email, mail.outbox[1].cc)
self.assertEqual(mail.outbox[1].subject,
f"{request.title} | Hozzászólás érkezett")
def test_logout_other_account(self):
login_url = reverse("login_obtain_jwt_pair")
logout_url = reverse("logout")
# Create two users
u1 = create_user()
u2 = create_user()
# Login to both users
resp_u1 = self.client.post(
login_url,
{
"username": u1.username,
"password": get_default_password()
},
format="json",
)
self.assertEqual(resp_u1.status_code, status.HTTP_200_OK)
resp_u2 = self.client.post(
login_url,
{
"username": u2.username,
"password": get_default_password()
},
format="json",
)
self.assertEqual(resp_u2.status_code, status.HTTP_200_OK)
# Set tokens
access_token_u1 = resp_u1.data["access"]
refresh_token_u2 = resp_u2.data["refresh"]
# When the user tries to logout using another user's refresh token an error should occur
self.client.credentials(HTTP_AUTHORIZATION=f"Bearer {access_token_u1}")
resp = self.client.post(logout_url, {"refresh": refresh_token_u2},
format="json")
self.assertEqual(resp.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(resp.data["detail"], "Token is invalid or expired")
def test_external_callback_for_status_change_works(
self, mock_notify_sch_event_management_system):
data = self._create_request_test_data
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
request_id1 = response.data["id"]
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
request_id2 = response.data["id"]
admin_user = create_user(is_admin=True)
self.authorize_user(admin_user)
# Request changed from Requested to Accepted
self.client.patch(f"{self.admin_url}/{request_id1}",
{"additional_data": {
"accepted": True
}})
mock_notify_sch_event_management_system.assert_called()
self.assertTrue(
mock_notify_sch_event_management_system.call_args.args[1])
# Request changed from Requested to Denied
self.client.patch(f"{self.admin_url}/{request_id2}",
{"additional_data": {
"accepted": False
}})
mock_notify_sch_event_management_system.assert_called()
self.assertFalse(
mock_notify_sch_event_management_system.call_args.args[1])
# Request changed from Accepted to Denied
self.client.patch(f"{self.admin_url}/{request_id1}",
{"additional_data": {
"accepted": False
}})
mock_notify_sch_event_management_system.assert_called()
self.assertFalse(
mock_notify_sch_event_management_system.call_args.args[1])
# Request changed from Denied to Accepted
self.client.patch(f"{self.admin_url}/{request_id2}",
{"additional_data": {
"accepted": True
}})
mock_notify_sch_event_management_system.assert_called()
self.assertTrue(
mock_notify_sch_event_management_system.call_args.args[1])
def setUp(self):
self.url = "/api/v1/admin/requests"
self.user = create_user(is_admin=True)
url = reverse("login_obtain_jwt_pair")
resp = self.client.post(
url,
{
"username": self.user.username,
"password": get_default_password()
},
format="json",
)
token = resp.data["access"]
self.client.credentials(HTTP_AUTHORIZATION=f"Bearer {token}")
self.request1 = create_request(100,
self.user,
start="2020-03-10T19:30:00+0100")
self.request2 = create_request(101,
self.user,
start="2020-07-07T19:30:00+0100")
self.request3 = create_request(102,
self.user,
start="2020-12-24T19:30:00+0100")
self.video1 = create_video(200, self.request1)
self.video2 = create_video(201, self.request2)
self.video2.additional_data = {
"aired": [
"2020-01-12",
"2019-11-25",
"2020-10-25",
"2018-05-19",
"2020-07-14",
]
}
self.video2.save()
self.video3 = create_video(202, self.request3)
self.video3.additional_data = {
"aired": [
"2019-03-03",
"2020-04-04",
"2018-02-02",
],
"length": 152,
}
self.video3.save()
def test_external_callback_for_status_change_redirect_and_result_works(
self, mock_requests_head, mock_requests_post):
data = self._create_request_test_data
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
request_id = response.data["id"]
def mock_head_redirect_response():
r = requests.Response()
r.status_code = 504
r.url = "https://redirected.example.com/api/callback/123"
return r
def mock_post_response():
r = requests.Response()
r.status_code = 200
r.json = lambda: {"status": "ok"}
return r
mock_requests_head.return_value = mock_head_redirect_response()
mock_requests_post.return_value = mock_post_response()
admin_user = create_user(is_admin=True)
self.authorize_user(admin_user)
self.client.patch(f"{self.admin_url}/{request_id}",
{"additional_data": {
"accepted": True
}})
mock_requests_head.assert_called_once()
mock_requests_post.assert_called_once()
mock_requests_post.assert_called_with(
mock_head_redirect_response().url,
data={"accept": True},
headers={
"Accept": "application/json",
"Authorization": f"Bearer {settings.SCH_EVENTS_TOKEN}",
},
allow_redirects=False,
)
self.assertDictEqual(
json.loads(
TaskResult.objects.get(
task_args__contains="api/callback/123").result),
{"status": "ok"},
)
def test_logout(self):
login_url = reverse("login_obtain_jwt_pair")
refresh_url = reverse("login_refresh_jwt_token")
logout_url = reverse("logout")
# Create a user
u = create_user()
# Login and check all data is present
resp = self.client.post(
login_url,
{
"username": u.username,
"password": get_default_password()
},
format="json",
)
self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertTrue("access" in resp.data)
self.assertTrue("refresh" in resp.data)
# Set tokens
access_token = resp.data["access"]
refresh_token = resp.data["refresh"]
# Try to logout without token in header
resp = self.client.post(logout_url, {"refresh": refresh_token},
format="json")
self.assertEqual(resp.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(resp.data["detail"],
"Authentication credentials were not provided.")
# Set Header and try again
self.client.credentials(HTTP_AUTHORIZATION=f"Bearer {access_token}")
resp = self.client.post(logout_url, {"refresh": refresh_token},
format="json")
self.assertEqual(resp.status_code, status.HTTP_205_RESET_CONTENT)
# Try to get new access token with blacklisted refresh token
resp = self.client.post(refresh_url, {"refresh": refresh_token},
format="json")
self.assertEqual(resp.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(resp.data["detail"], "Token is blacklisted")
def test_new_comment_email_not_sent_to_banned_user_admin_endpoint(self):
# Setup data - Create a Request, add Crew members and Responsible
banned_user = create_user(banned=True)
request = create_request(100, banned_user)
# New comment data
data = {"text": "New comment", "internal": False}
# Authorized staff user and create new comment
self.authorize_user(self.staff_user)
response = self.client.post(
f"/api/v1/admin/requests/{request.id}/comments", data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Check if e-mail was sent to the right people
self.assertEqual(len(mail.outbox), 1)
self.assertNotIn(banned_user.email, mail.outbox[0].to)
self.assertNotIn(banned_user.email, mail.outbox[0].cc)
self.assertNotIn(banned_user.email, mail.outbox[0].bcc)
def test_admin_can_ban_and_unban_user(self):
user = create_user()
self.authorize_user(self.admin)
response = self.client.post(f"{self.url}/{user.id}/ban")
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.check_if_user_is_banned(user.id, True)
response = self.client.delete(f"{self.url}/{user.id}/ban")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.check_if_user_is_banned(user.id, False)
response = self.client.post(f"{self.url}/{user.id}/ban",
{"reason": "test"})
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.check_if_user_is_banned(user.id, True, "test")
response = self.client.delete(f"{self.url}/{user.id}/ban")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.check_if_user_is_banned(user.id, False)
def test_refresh_token_after_ban(self):
user = create_user()
login_url = reverse("login_obtain_jwt_pair")
refresh_url = reverse("login_refresh_jwt_token")
# Login and blacklisted the refresh token
# to test exception handling in signals.py
response = self.client.post(
login_url,
{
"username": user.username,
"password": get_default_password()
},
format="json",
)
token = RefreshToken(response.data["refresh"])
token.blacklist()
# Login again and try the main flow
response = self.client.post(
login_url,
{
"username": user.username,
"password": get_default_password()
},
format="json",
)
access_token = response.data["access"]
refresh_token = response.data["refresh"]
self.authorize_user(self.admin)
response = self.client.post(f"{self.url}/{user.id}/ban")
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.check_if_user_is_banned(user.id, True)
self.client.credentials(HTTP_AUTHORIZATION=f"Bearer {access_token}")
response = self.client.post(refresh_url, {"refresh": refresh_token},
format="json")
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(str(response.data["detail"]), "Token is blacklisted")
def test_external_request_creation_existing_user(self):
existing_user = create_user()
data = self._create_request_test_data | {
"requester_email": existing_user.email,
}
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
req = Request.objects.get(pk=response.data["id"])
self.assertEqual(req.requester, existing_user)
self.assertEqual(req.requested_by, self.user)
self.assertEqual(
req.additional_data["external"]["sch_events_callback_url"],
data["callback_url"],
)
self.assertEqual(req.additional_data["requester"]["first_name"],
data["requester_first_name"])
self.assertEqual(req.additional_data["requester"]["last_name"],
data["requester_last_name"])
self.assertEqual(req.additional_data["requester"]["phone_number"],
data["requester_mobile"])
def test_external_callback_for_status_change_retry_works(
self, mock_requests_post):
data = self._create_request_test_data
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
request_id = response.data["id"]
def mock_response():
r = requests.Response()
r.status_code = 500
return r
mock_requests_post.return_value = mock_response()
admin_user = create_user(is_admin=True)
self.authorize_user(admin_user)
self.client.patch(f"{self.admin_url}/{request_id}",
{"additional_data": {
"accepted": True
}})
self.assertEqual(mock_requests_post.call_count, 11)
def test_login(self):
url = reverse("login_obtain_jwt_pair")
password = get_default_password()
# Create inactive user
u = create_user()
u.is_active = False
u.save()
# Try login with e-mail - Should return error
resp = self.client.post(url, {
"email": u.email,
"password": password
},
format="json")
self.assertEqual(resp.status_code, status.HTTP_400_BAD_REQUEST)
# Try login with username (still inactive) - Should return error
resp = self.client.post(url, {
"username": u.username,
"password": password
},
format="json")
self.assertEqual(resp.status_code, status.HTTP_401_UNAUTHORIZED)
# Set user to active
u.is_active = True
u.save()
# Try login with active profile - Should return the JWT token
resp = self.client.post(url, {
"username": u.username,
"password": password
},
format="json")
self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertTrue("access" in resp.data)
self.assertTrue("refresh" in resp.data)
def test_check_and_remove_unauthorized_additional_data_for_request_from_staff(self):
staff_member = create_user(is_staff=True)
self.authorize_user(staff_member)
# Create Request
response = self.client.post(self.url, get_test_data())
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data["status"], Request.Statuses.REQUESTED)
request_id = response.data["id"]
# Try to add unauthorized additional_data parts
response = self.patch_additional_data_to_request(request_id)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn("recording", response.data["additional_data"])
self.assertIn("path", response.data["additional_data"]["recording"])
self.assertIn("copied_to_gdrive", response.data["additional_data"]["recording"])
self.assertIn("removed", response.data["additional_data"]["recording"])
self.assertNotIn("status_by_admin", response.data["additional_data"])
self.assertNotIn("accepted", response.data["additional_data"])
self.assertNotIn("canceled", response.data["additional_data"])
self.assertNotIn("failed", response.data["additional_data"])
self.assertNotIn("calendar_id", response.data["additional_data"])
self.assertNotIn("requester", response.data["additional_data"])
def create_inactive_staff_user():
user = create_user(is_staff=True)
user.is_active = False
user.save()
def test_list_users_filters_works(self):
# Create a user that has admin right but not staff
only_admin_user = create_user()
only_admin_user.is_superuser = True
only_admin_user.save()
self.authorize_user(self.admin)
response = self.client.get(f"{self.url}?staff=False")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["count"], 2)
self.assertIn(
response.data["results"][0]["username"],
[self.user.username, only_admin_user.username],
)
self.assertIn(
response.data["results"][1]["username"],
[self.user.username, only_admin_user.username],
)
response = self.client.get(f"{self.url}?staff=True")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["count"], 2)
self.assertIn(
response.data["results"][0]["username"],
[self.staff.username, self.admin.username],
)
self.assertIn(
response.data["results"][1]["username"],
[self.staff.username, self.admin.username],
)
response = self.client.get(f"{self.url}?admin=False")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["count"], 2)
self.assertIn(
response.data["results"][0]["username"],
[self.user.username, self.staff.username],
)
self.assertIn(
response.data["results"][1]["username"],
[self.user.username, self.staff.username],
)
response = self.client.get(f"{self.url}?admin=True")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["count"], 2)
self.assertIn(
response.data["results"][0]["username"],
[only_admin_user.username, self.admin.username],
)
self.assertIn(
response.data["results"][1]["username"],
[only_admin_user.username, self.admin.username],
)
response = self.client.get(f"{self.url}?admin=False&staff=False")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["count"], 1)
self.assertEqual(self.user.username,
response.data["results"][0]["username"])
response = self.client.get(f"{self.url}?admin=True&staff=False")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["count"], 1)
self.assertEqual(only_admin_user.username,
response.data["results"][0]["username"])
response = self.client.get(f"{self.url}?staff=True&admin=False")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["count"], 1)
self.assertEqual(self.staff.username,
response.data["results"][0]["username"])
response = self.client.get(f"{self.url}?staff=True&admin=True")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["count"], 1)
self.assertEqual(self.admin.username,
response.data["results"][0]["username"])
def setUp(self):
self.url = "/api/v1/users"
self.admin = create_user(is_admin=True)
self.staff = create_user(is_staff=True)
self.user = create_user()
# Worked on Requests
# 20 weeks before today
self.request1 = create_request(100,
self.user,
start="2020-07-07T20:00:00+0100",
responsible=self.admin)
self.request2 = create_request(101,
self.user,
start="2020-07-13T20:00:00+0100",
responsible=self.staff)
create_crew(200, self.request1, self.admin, "Cameraman")
create_crew(201, self.request2, self.admin, "Technician")
create_crew(202, self.request1, self.staff, "Reporter")
create_video(300, self.request1, editor=self.admin)
create_video(301, self.request1, editor=self.staff)
# Before 2020-11-01
self.request3 = create_request(102,
self.user,
start="2020-10-10T20:00:00+0100",
responsible=self.admin)
self.request4 = create_request(103,
self.user,
start="2020-10-25T20:00:00+0100",
responsible=self.staff)
create_crew(203, self.request3, self.admin, "Cameraman")
create_crew(204, self.request4, self.admin, "Technician")
create_crew(205, self.request3, self.staff, "Reporter")
create_video(302, self.request3, editor=self.admin)
create_video(303, self.request3, editor=self.staff)
# Between 2020-11-01 and 2020-12-01
self.request5 = create_request(104,
self.user,
start="2020-11-10T20:00:00+0100",
responsible=self.admin)
self.request6 = create_request(105,
self.user,
start="2020-11-25T20:00:00+0100",
responsible=self.staff)
create_crew(206, self.request5, self.admin, "Cameraman")
create_crew(207, self.request5, self.admin, "Technician")
create_crew(208, self.request5, self.staff, "Reporter")
create_crew(209, self.request6, self.staff, "Technician")
create_video(304, self.request5, editor=self.staff)
create_video(305, self.request6, editor=self.staff)
# After 2020-12-01
self.request7 = create_request(106,
self.user,
start="2020-12-10T20:00:00+0100",
responsible=self.admin)
self.request8 = create_request(107,
self.user,
start="2020-12-25T20:00:00+0100",
responsible=self.staff)
create_crew(210, self.request8, self.admin, "Cameraman")
create_crew(211, self.request7, self.staff, "Reporter")
create_crew(212, self.request8, self.staff, "Technician")
create_video(306, self.request7, editor=self.admin)
create_video(307, self.request8, editor=self.admin)
create_video(308, self.request7, editor=self.staff)
create_video(309, self.request8, editor=self.staff)
def test_overdue_requests_email_sent_to_editor_in_chief_and_production_manager(
self, mock_email_responsible_overdue_request):
# Setup test objects
new_staff_member = create_user(is_staff=True)
overdue1 = create_request(
100,
self.normal_user,
start="2020-10-05T18:00:00+0100",
responsible=self.staff_user,
)
overdue2 = create_request(
101,
self.normal_user,
Request.Statuses.UPLOADED,
start="2020-09-29T15:30:00+0100",
responsible=new_staff_member,
)
create_request(
102,
self.normal_user,
Request.Statuses.ARCHIVED,
start="2020-09-29T15:30:00+0100",
)
create_request(
103,
self.normal_user,
Request.Statuses.UPLOADED,
start="2020-11-05T21:00:00+0100",
)
"""
Case 1: Some overdue Requests
"""
# Call management command
with StringIO() as out:
call_command("email_overdue_requests", stdout=out)
self.assertEqual(
out.getvalue(),
f"Overdue request email was sent successfully. ({overdue1.title})\nOverdue request email was sent successfully. ({overdue2.title})\n",
)
# Check if function was called with correct parameters
mock_email_responsible_overdue_request.assert_called()
self.assertEqual(mock_email_responsible_overdue_request.call_count, 2)
# Check if e-mail was sent to the right people
self.assertEqual(len(mail.outbox), 2)
self.assertIn(self.staff_user.email, mail.outbox[0].to)
self.assertIn(self.production_manager.email, mail.outbox[0].cc)
self.assertIn(self.editor_in_chief.email, mail.outbox[0].cc)
self.assertEqual(mail.outbox[0].subject,
f"Lejárt határidejű felkérés - {overdue1.title}")
self.assertIn(new_staff_member.email, mail.outbox[1].to)
self.assertIn(self.production_manager.email, mail.outbox[1].cc)
self.assertIn(self.editor_in_chief.email, mail.outbox[1].cc)
self.assertEqual(mail.outbox[1].subject,
f"Lejárt határidejű felkérés - {overdue2.title}")
"""
Case 2: No overdue Request until today
"""
# Change the previous Request statuses
overdue1.status = Request.Statuses.EDITED
overdue1.save()
overdue2.status = Request.Statuses.DONE
overdue2.save()
# Reset mock
mock_email_responsible_overdue_request.reset_mock()
# Call management command
with StringIO() as out:
call_command("email_overdue_requests", stdout=out)
self.assertEqual(
out.getvalue(),
"No overdue request was found.\n",
)
# Check if function was called with correct parameters
mock_email_responsible_overdue_request.assert_not_called()
def setUp(self):
self.user = create_user()
