def test_daily_reminder_email_sent_to_crew(self,
mock_email_crew_daily_reminder,
frozen_time):
# Create test Requests
with_crew = create_request(100,
self.normal_user,
start="2020-11-19T18:00:00+0100")
without_crew = create_request(101,
self.normal_user,
start="2020-11-19T20:00:00+0100")
crew1 = create_crew(201, with_crew, self.staff_user, "Cameraman")
crew2 = create_crew(202, with_crew, self.editor_in_chief, "Reporter")
"""
Case 1: Successful e-mail sending
"""
# Call management command
with StringIO() as out:
call_command("email_daily_reminders", stdout=out)
self.assertEqual(
out.getvalue(),
"1 reminders were sent to crew members. There are 2 request(s) today.\n",
)
# Check if function was called with correct parameters
mock_email_crew_daily_reminder.assert_called_once()
self.assertEqual(with_crew,
mock_email_crew_daily_reminder.call_args.args[0])
self.assertNotEqual(without_crew,
mock_email_crew_daily_reminder.call_args.args[0])
self.assertIn(crew1, mock_email_crew_daily_reminder.call_args.args[1])
self.assertIn(crew2, mock_email_crew_daily_reminder.call_args.args[1])
# Check if e-mail was sent to the right people
self.assertEqual(len(mail.outbox), 1)
self.assertIn(crew1.member.email, mail.outbox[0].to)
self.assertIn(crew2.member.email, mail.outbox[0].to)
self.assertEqual(mail.outbox[0].subject,
f"Emlékeztető | {with_crew.title} | Mai forgatás")
"""
Case 2: No Request for today
"""
# Change time to next day
frozen_time.move_to("2020-11-20 10:20:30")
# Call management command
with StringIO() as out:
call_command("email_daily_reminders", stdout=out)
self.assertEqual(out.getvalue(), "No reminders for today.\n")
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_video_published_email_sent_to_user(self):
# Setup data - Create a Request with status 4, and a video
request = create_request(100, self.normal_user,
Request.Statuses.UPLOADED)
video = create_video(300, request, Video.Statuses.PENDING)
# Video data to be patched
data = {
"editor_id": self.staff_user.id,
"additional_data": {
"editing_done": True,
"coding": {
"website": True
},
"publishing": {
"website": "https://example.com"
},
},
}
# Authorized staff user and update video data
self.authorize_user(self.staff_user)
response = self.client.patch(
f"/api/v1/admin/requests/{request.id}/videos/{video.id}", data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Check if e-mail was sent to the right people
self.assertEqual(len(mail.outbox), 1)
self.assertIn(self.normal_user.email, mail.outbox[0].to)
self.assertIn(self.pr_responsible.email, mail.outbox[0].bcc)
self.assertIn(settings.DEFAULT_REPLY_EMAIL, mail.outbox[0].reply_to)
self.assertEqual(mail.outbox[0].subject,
f"{video.request.title} | Új videót publikáltunk")
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):
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 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_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 test_request_no_deadline_recalculation_old_end_datetime_in_body(self):
request = create_request(100, self.user)
body = {
"start_datetime": request.start_datetime + timedelta(hours=4),
"end_datetime": request.end_datetime,
}
response = self.client.patch(f"{self.url}/{request.id}", body)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["deadline"], str(request.deadline))
def test_request_deadline_recalculate_old_deadline_in_body(self):
request = create_request(100, self.user)
body = {
"end_datetime": "2020-12-31T10:30:00+01:00",
"deadline": request.deadline,
}
response = self.client.patch(f"{self.url}/{request.id}", body)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["deadline"], "2021-01-21")
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_request_additional_data_validation(self):
request = create_request(100, self.user)
response = self.client.patch(
f"{self.url}/{request.id}",
{"additional_data": {"randomKey": "randomValue"}},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn(
"Additional properties are not allowed ('randomKey' was unexpected)",
response.data["additional_data"][0],
)
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_request_no_deadline_recalculation_custom_original_deadline(self):
request = create_request(100, self.user)
request.deadline = (request.end_datetime + timedelta(days=5)).date()
request.save()
body = {"end_datetime": "2020-12-31T10:30:00+01:00"}
response = self.client.patch(f"{self.url}/{request.id}", body)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
response.data["deadline"][0],
"Must be later than end of the event.",
)
body = {
"end_datetime": "2020-12-31T10:30:00+01:00",
"deadline": request.deadline,
}
response = self.client.patch(f"{self.url}/{request.id}", body)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
response.data["deadline"][0],
"Must be later than end of the event.",
)
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_modifying_requester_should_not_interfere_with_existing_additional_data(
self,
):
request = create_request(100, self.user)
self.patch_additional_data_to_request(request.id)
# Existing additional_data should not disappear
existing_user_data = {
"requester_first_name": "Anonymous",
"requester_last_name": "Tester",
"requester_email": self.user.email,
"requester_mobile": "+36701234567",
}
response = self.client.patch(f"{self.url}/{request.id}", existing_user_data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["requester"]["username"], self.user.username)
self.assertEqual(
response.data["requested_by"]["username"], self.user.username
)
expected_dict = (
self._patch_data["additional_data"]
| {
"status_by_admin": {
"status": Request.Statuses.ARCHIVED,
"admin_id": self.user.id,
"admin_name": self.user.get_full_name_eastern_order(),
}
}
| {
"requester": {
"first_name": "Anonymous",
"last_name": "Tester",
"phone_number": "+36701234567",
}
}
)
self.assertDictEqual(response.data["additional_data"], expected_dict)
def test_video_additional_data_aired_get_sorted_by_date(self):
request = create_request(100, self.user)
video = create_video(200, request)
data = {
"additional_data": {
"aired": [
"2020-01-12",
"2019-11-25",
"2020-10-25",
"2018-05-19",
"2020-07-14",
]
}
}
response = self.client.patch(f"{self.url}/{request.id}/videos/{video.id}", data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertListEqual(
response.data["additional_data"]["aired"],
["2020-10-25", "2020-07-14", "2020-01-12", "2019-11-25", "2018-05-19"],
)
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_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 test_unfinished_requests_email_sent_to_production_manager(
self, mock_email_production_manager_unfinished_requests):
# Setup test Requests
not_incl_1 = create_request(100, self.normal_user,
Request.Statuses.ACCEPTED)
not_incl_2 = create_request(101, self.normal_user,
Request.Statuses.UPLOADED)
not_incl_3 = create_request(102, self.normal_user,
Request.Statuses.DONE)
incl_1 = create_request(103, self.normal_user, Request.Statuses.EDITED)
incl_2 = create_request(104, self.normal_user,
Request.Statuses.ARCHIVED)
"""
Case 1: Some unfinished Requests
"""
# Call management command
with StringIO() as out:
call_command("email_unfinished_requests", stdout=out)
self.assertEqual(
out.getvalue(),
"Unfinished requests email was sent successfully.\n")
# Check if function was called with correct parameters
mock_email_production_manager_unfinished_requests.assert_called_once()
self.assertEqual(
len(mock_email_production_manager_unfinished_requests.call_args.
args[0]), 2)
self.assertIn(
incl_1, mock_email_production_manager_unfinished_requests.
call_args.args[0])
self.assertIn(
incl_2, mock_email_production_manager_unfinished_requests.
call_args.args[0])
self.assertNotIn(
not_incl_1,
mock_email_production_manager_unfinished_requests.call_args.
args[0],
)
self.assertNotIn(
not_incl_2,
mock_email_production_manager_unfinished_requests.call_args.
args[0],
)
self.assertNotIn(
not_incl_3,
mock_email_production_manager_unfinished_requests.call_args.
args[0],
)
# Check if e-mail was sent to the right people
self.assertEqual(len(mail.outbox), 1)
self.assertIn(self.production_manager.email, mail.outbox[0].to)
self.assertEqual(mail.outbox[0].subject, "Lezáratlan anyagok")
"""
Case 2: No unfinished Request
"""
# Delete the included Requests
incl_1.delete()
incl_2.delete()
# Reset mock
mock_email_production_manager_unfinished_requests.reset_mock()
# Call management command
with StringIO() as out:
call_command("email_unfinished_requests", stdout=out)
self.assertEqual(out.getvalue(), "All requests are finished.\n")
# Check if function was called with correct parameters
mock_email_production_manager_unfinished_requests.assert_not_called()
def setUp(self):
self.url = "/api/v1/admin/statistics/requests"
self.admin = create_user(is_admin=True)
self.staff = create_user(is_staff=True)
self.user = create_user()
# Requests before 2020-11-01
# Requested status
create_request(100,
self.user,
Request.Statuses.REQUESTED,
start="2020-10-16T20:00:00+0100")
create_request(101,
self.user,
Request.Statuses.REQUESTED,
start="2020-10-22T20:00:00+0100")
# In progress (between Accepted and Archived)
create_request(102,
self.user,
Request.Statuses.UPLOADED,
start="2020-10-05T20:00:00+0100")
# Completed (Done)
create_request(103,
self.user,
Request.Statuses.DONE,
start="2020-10-10T20:00:00+0100")
create_request(104,
self.user,
Request.Statuses.DONE,
start="2020-10-30T20:00:00+0100")
create_request(105,
self.user,
Request.Statuses.DONE,
start="2020-10-08T20:00:00+0100")
# Upcoming (Accepted)
self.upcoming1 = create_request(106,
self.user,
Request.Statuses.ACCEPTED,
start="2020-10-29T20:00:00+0100")
self.upcoming2 = create_request(107,
self.user,
Request.Statuses.ACCEPTED,
start="2020-10-02T20:00:00+0100")
# Requests between 2020-11-01 and 2020-12-01
# Requested status
create_request(200,
self.user,
Request.Statuses.REQUESTED,
start="2020-11-16T20:00:00+0100")
create_request(201,
self.user,
Request.Statuses.REQUESTED,
start="2020-11-22T20:00:00+0100")
# In progress (between Accepted and Archived)
create_request(202,
self.user,
Request.Statuses.UPLOADED,
start="2020-11-05T20:00:00+0100")
create_request(203,
self.user,
Request.Statuses.RECORDED,
start="2020-11-10T20:00:00+0100")
create_request(204,
self.user,
Request.Statuses.ARCHIVED,
start="2020-11-30T20:00:00+0100")
# Completed (Done)
create_request(205,
self.user,
Request.Statuses.DONE,
start="2020-11-08T20:00:00+0100")
# Upcoming (Accepted)
self.upcoming3 = create_request(206,
self.user,
Request.Statuses.ACCEPTED,
start="2020-11-29T20:00:00+0100")
self.upcoming4 = create_request(207,
self.user,
Request.Statuses.ACCEPTED,
start="2020-11-02T20:00:00+0100")
# Requests after 2020-12-01
# Requested status
create_request(300,
self.user,
Request.Statuses.REQUESTED,
start="2020-12-16T20:00:00+0100")
create_request(301,
self.user,
Request.Statuses.REQUESTED,
start="2020-12-22T20:00:00+0100")
create_request(302,
self.user,
Request.Statuses.REQUESTED,
start="2020-12-05T20:00:00+0100")
# In progress (between Accepted and Archived)
create_request(303,
self.user,
Request.Statuses.RECORDED,
start="2020-12-10T20:00:00+0100")
create_request(304,
self.user,
Request.Statuses.ARCHIVED,
start="2020-12-30T20:00:00+0100")
# Completed (Done)
create_request(305,
self.user,
Request.Statuses.DONE,
start="2020-12-08T20:00:00+0100")
# Upcoming (Accepted)
self.upcoming5 = create_request(306,
self.user,
Request.Statuses.ACCEPTED,
start="2020-12-29T20:00:00+0100")
self.upcoming6 = create_request(307,
self.user,
Request.Statuses.ACCEPTED,
start="2020-12-02T20:00:00+0100")
# Videos before 2020-11-01
self.video1 = create_video(400, self.upcoming2)
self.video2 = create_video(401, self.upcoming2)
self.video3 = create_video(402, self.upcoming2) # No related rating
# Video1 ratings - Avg: 4.3
create_rating(500, self.video1, self.user, 5)
create_rating(501, self.video1, self.staff, 4)
create_rating(502, self.video1, self.admin, 4)
# Video2 ratings - Avg: 3.3
create_rating(503, self.video2, self.user, 3)
create_rating(504, self.video2, self.staff, 3)
create_rating(505, self.video2, self.admin, 4)
# Videos between 2020-11-01 and 2020-12-01
self.video4 = create_video(403, self.upcoming4)
self.video5 = create_video(404, self.upcoming4)
self.video6 = create_video(405, self.upcoming4) # No related rating
# Video4 ratings - Avg: 5.0
create_rating(506, self.video4, self.user, 5)
create_rating(507, self.video4, self.staff, 5)
create_rating(508, self.video4, self.admin, 5)
# Video5 ratings - Avg: 2.0
create_rating(509, self.video5, self.user, 2)
create_rating(510, self.video5, self.staff, 1)
create_rating(511, self.video5, self.admin, 3)
# Videos after 2020-12-01
self.video7 = create_video(406, self.upcoming6)
self.video8 = create_video(407, self.upcoming6)
self.video9 = create_video(408, self.upcoming6) # No related rating
# Video7 ratings - Avg: 4.0
create_rating(512, self.video7, self.user, 4)
create_rating(513, self.video7, self.staff, 4)
create_rating(514, self.video7, self.admin, 4)
# Video8 ratings - Avg: 3.6
create_rating(515, self.video8, self.user, 5)
create_rating(516, self.video8, self.staff, 3)
create_rating(517, self.video8, self.admin, 3)
def test_weekly_staff_email_sending(self, mock_email_staff_weekly_tasks,
frozen_time):
# Create test Requests - Recording
# Should be included
rec1 = create_request(100,
self.normal_user,
start="2020-11-16T04:16:13+0100")
rec2 = create_request(
101,
self.normal_user,
Request.Statuses.ACCEPTED,
start="2020-11-21T21:41:57+0100",
)
# Should not be included
rec3 = create_request(
102, self.normal_user,
start="2020-11-15T10:01:24+0100") # previous week
rec4 = create_request(103,
self.normal_user,
start="2020-11-24T17:22:05+0100") # next week
rec5 = create_request(
104,
self.normal_user,
Request.Statuses.EDITED,
start="2020-11-20T14:55:45+0100",
) # this week but wrong status
# Create test Requests - Editing
# Should be included
edit1 = create_request(110, self.normal_user,
Request.Statuses.RECORDED)
edit2 = create_request(111, self.normal_user,
Request.Statuses.UPLOADED)
edit_vid21 = create_video(211, edit2, Video.Statuses.PENDING)
edit_vid22 = create_video(212, edit2, Video.Statuses.IN_PROGRESS,
self.staff_user)
# Should not be included
edit3 = create_request(112, self.normal_user,
Request.Statuses.EDITED) # later status
edit4 = create_request(
113, self.normal_user,
Request.Statuses.RECORDED) # good status but wrong status video
edit_vid41 = create_video(213, edit4, Video.Statuses.EDITED)
edit5 = create_request(
114, self.normal_user,
Request.Statuses.EDITED) # wrong status but good status video
edit_vid51 = create_video(214, edit5, Video.Statuses.PENDING)
"""
Case 1: Successful e-mail sending
"""
# Call management command
with StringIO() as out:
call_command("email_weekly_tasks", stdout=out)
self.assertEqual(out.getvalue(),
"Weekly tasks email was sent successfully.\n")
# Check if fuction was called with correct parameters
mock_email_staff_weekly_tasks.assert_called_once()
self.assertEqual(len(mock_email_staff_weekly_tasks.call_args.args[0]),
2)
self.assertIn(rec1, mock_email_staff_weekly_tasks.call_args.args[0])
self.assertIn(rec2, mock_email_staff_weekly_tasks.call_args.args[0])
self.assertNotIn(rec3, mock_email_staff_weekly_tasks.call_args.args[0])
self.assertNotIn(rec4, mock_email_staff_weekly_tasks.call_args.args[0])
self.assertNotIn(rec5, mock_email_staff_weekly_tasks.call_args.args[0])
self.assertEqual(len(mock_email_staff_weekly_tasks.call_args.args[1]),
1)
self.assertIn(edit1, mock_email_staff_weekly_tasks.call_args.args[1])
self.assertNotIn(edit2,
mock_email_staff_weekly_tasks.call_args.args[1])
self.assertNotIn(edit3,
mock_email_staff_weekly_tasks.call_args.args[1])
self.assertNotIn(edit4,
mock_email_staff_weekly_tasks.call_args.args[1])
self.assertNotIn(edit5,
mock_email_staff_weekly_tasks.call_args.args[1])
self.assertEqual(len(mock_email_staff_weekly_tasks.call_args.args[2]),
2)
self.assertIn(edit_vid21,
mock_email_staff_weekly_tasks.call_args.args[2])
self.assertIn(edit_vid22,
mock_email_staff_weekly_tasks.call_args.args[2])
self.assertNotIn(edit_vid41,
mock_email_staff_weekly_tasks.call_args.args[2])
self.assertNotIn(edit_vid51,
mock_email_staff_weekly_tasks.call_args.args[2])
# Check if e-mail was sent to the right people
self.assertEqual(len(mail.outbox), 1)
self.assertIn(settings.WEEKLY_TASK_EMAIL, mail.outbox[0].to)
self.assertEqual(mail.outbox[0].subject,
"Eheti forgatások és vágandó anyagok")
"""
Case 2: No Request for the week.
"""
# Change time to next month
frozen_time.move_to("2020-12-21 10:20:30")
# Change editing objects
edit1.status = Request.Statuses.EDITED
edit1.save()
edit2.status = Request.Statuses.ARCHIVED
edit2.save()
# Call management command
with StringIO() as out:
call_command("email_weekly_tasks", stdout=out)
self.assertEqual(out.getvalue(), "No tasks for this week.\n")
def test_publishing_email_sent_to_user_in_video_additional_data_should_not_be_overwritten(
self,
):
request = create_request(100, self.user, Request.Statuses.UPLOADED)
staff = create_user(is_staff=True)
# Add a video with some data
video_data = {
"title": "New video",
"editor_id": self.user.id,
"additional_data": {
"editing_done": True,
"coding": {"website": True},
},
}
response = self.client.post(f"{self.url}/{request.id}/videos", video_data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data["status"], Video.Statuses.CODED)
video_id = response.data["id"]
# Try to add email_sent_to_user before defined with admin user
self.authorize_user(self.user)
response = self.client.patch(
f"{self.url}/{request.id}/videos/{video_id}",
{"additional_data": {"publishing": {"email_sent_to_user": False}}},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn("publishing", response.data["additional_data"])
self.assertNotIn(
"email_sent_to_user", response.data["additional_data"]["publishing"]
)
# Try with staff
self.authorize_user(staff)
response = self.client.patch(
f"{self.url}/{request.id}/videos/{video_id}",
{"additional_data": {"publishing": {"email_sent_to_user": False}}},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn("publishing", response.data["additional_data"])
self.assertNotIn(
"email_sent_to_user", response.data["additional_data"]["publishing"]
)
# Request was updated due to changes is video so the forced status was changed. Change again
request.status = Request.Statuses.UPLOADED
request.save()
# Publish video
response = self.client.patch(
f"{self.url}/{request.id}/videos/{video_id}",
{"additional_data": {"publishing": {"website": "https://example.com"}}},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["status"], Video.Statuses.PUBLISHED)
# Because of the async tasks the email_sent_to_user might not be in the response. Get the video again and check
response = self.client.get(f"{self.url}/{request.id}/videos/{video_id}")
self.assertIn("publishing", response.data["additional_data"])
self.assertIn(
"email_sent_to_user", response.data["additional_data"]["publishing"]
)
self.assertEqual(
response.data["additional_data"]["publishing"]["email_sent_to_user"], True
)
# Try to modify email_sent_to_user with admin user
self.authorize_user(self.user)
response = self.client.patch(
f"{self.url}/{request.id}/videos/{video_id}",
{"additional_data": {"publishing": {"email_sent_to_user": False}}},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response.data["additional_data"]["publishing"]["email_sent_to_user"], True
)
self.assertNotEqual(
response.data["additional_data"]["publishing"]["email_sent_to_user"], False
)
# Try with staff
self.authorize_user(staff)
response = self.client.patch(
f"{self.url}/{request.id}/videos/{video_id}",
{"additional_data": {"publishing": {"email_sent_to_user": False}}},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response.data["additional_data"]["publishing"]["email_sent_to_user"], True
)
self.assertNotEqual(
response.data["additional_data"]["publishing"]["email_sent_to_user"], False
)
def test_external_request_retrieve_success(self):
user = create_user()
request = create_request(100, user, requested_by=self.user)
response = self.client.get(f"{self.url}/{request.id}")
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_service_account_should_not_access_other_endpoints(self):
request = create_request(100, self.user)
video = create_video(200, request)
comment = create_comment(300, request, self.user, False)
rating = create_rating(400, video, self.user)
# Default API
# Create Request
response = self.client.post(self.default_url,
self._create_request_test_data)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# List Requests
response = self.client.get(self.default_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# Retrieve Request
response = self.client.get(f"{self.default_url}/{request.id}")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# List Videos
response = self.client.get(f"{self.default_url}/{request.id}/videos")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# Retrieve Video
response = self.client.get(
f"{self.default_url}/{request.id}/videos/{video.id}")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# Create Comment
response = self.client.post(
f"{self.default_url}/{request.id}/comments", {"text": "Test"})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# List Comments
response = self.client.get(f"{self.default_url}/{request.id}/comments")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# Retrieve Comment
response = self.client.get(
f"{self.default_url}/{request.id}/comments/{comment.id}")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# Modify Comment
response = self.client.patch(
f"{self.default_url}/{request.id}/comments/{comment.id}",
{"text": "Test"})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# Delete Comment
response = self.client.delete(
f"{self.default_url}/{request.id}/comments/{comment.id}")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# Create Rating
response = self.client.post(
f"{self.default_url}/{request.id}/videos/{video.id}/ratings",
{"rating": 5})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# List Ratings
response = self.client.get(
f"{self.default_url}/{request.id}/videos/{video.id}/ratings")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# Retrieve Rating
response = self.client.get(
f"{self.default_url}/{request.id}/videos/{video.id}/ratings/{rating.id}"
)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# Modify Rating
response = self.client.patch(
f"{self.default_url}/{request.id}/videos/{video.id}/ratings/{rating.id}",
{"rating": 5},
)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# Delete Rating
response = self.client.delete(
f"{self.default_url}/{request.id}/videos/{video.id}/ratings/{rating.id}"
)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def handle(self, *args, **options):
ls = options["list"]
check = options["check"]
accept = options["accept"]
remove = options["remove"]
test = options["test"]
service = get_google_calendar_service()
if ls or check:
calendar_list = service.calendarList().list().execute()
if calendar_list["items"]:
for event in calendar_list["items"]:
if ls:
self.stdout.write(
self.style.SUCCESS(f'{event["summary"]} - {event["id"]}')
)
elif check:
if event["id"] == check:
self.stdout.write(
self.style.SUCCESS(
"Service account has access to the calendar."
)
)
else:
self.stdout.write(
self.style.ERROR(
"Service account does not have access to the calendar."
)
)
else:
self.stdout.write(
self.style.ERROR(
"Service account does not have access to any calendars."
)
)
elif accept:
event = {"id": accept}
service.calendarList().insert(body=event).execute()
self.stdout.write(
self.style.SUCCESS(
"Calendar was added to service account successfully."
)
)
elif remove:
service.calendarList().delete(calendarId=remove).execute()
self.stdout.write(
self.style.SUCCESS(
"Calendar was removed from service account successfully."
)
)
elif test:
request = create_request(999999, get_sentinel_user())
try:
# Which credential file are we using
self.stdout.write("----------- Key file path -----------")
self.stdout.write(settings.GOOGLE_SERVICE_ACCOUNT_KEY_FILE_PATH)
# Create the event
self.stdout.write("----------- Creating new event -----------")
self.stdout.write("The event will be created for today.")
self.stdout.write(
"It should contain: title, description, place, start and end datetime."
)
create_calendar_event(request.id)
self.stdout.write(self.style.SUCCESS("Event was saved successfully."))
input("Check and validate the calendar and press Enter to continue...")
# Change some data and update the event
self.stdout.write("----------- Updating the event -----------")
self.stdout.write("The event should be shifted one day forward.")
self.stdout.write(
"The following fields should be updated: title, place, start and end datetime."
)
request.refresh_from_db() # Refresh the object to contain calendar_id
request.title = "Changed title"
request.place = "Changed place"
request.end_datetime = request.end_datetime + timedelta(days=1)
request.start_datetime = request.start_datetime + timedelta(days=1)
request.save()
update_calendar_event(request.id)
self.stdout.write(self.style.SUCCESS("Event was updated successfully."))
input("Check and validate the calendar and press Enter to continue...")
# Delete the event from the calendar
self.stdout.write("----------- Deleting the event -----------")
remove_calendar_event(request.id)
self.stdout.write(
self.style.SUCCESS(
"Event was deleted successfully. Check the calendar."
)
)
finally:
request.delete()
else:
self.stdout.write(
self.style.ERROR("Please define exactly one argument or flag.")
)
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_token_refresh(self):
login_url = reverse("login_obtain_jwt_pair")
refresh_url = reverse("login_refresh_jwt_token")
# Create a user
u = create_user()
# Create test request for the user
r = create_request(101, u)
# 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 access token
access_token = resp.data["access"]
refresh_token = resp.data["refresh"]
self.client.credentials(HTTP_AUTHORIZATION=f"Bearer {access_token}")
# Check if token works and user can access request
resp = self.client.get("/api/v1/requests/" + str(r.id))
self.assertEqual(resp.status_code, status.HTTP_200_OK)
# Wait for the token to expire
sleep(10)
# The user should not be able to get the request because of the expired token
resp = self.client.get("/api/v1/requests/" + str(r.id))
self.assertEqual(resp.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(resp.data["code"], "token_not_valid")
# Use the refresh token for new access token
resp = self.client.post(refresh_url, {"refresh": refresh_token},
format="json")
self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertTrue("access" in resp.data)
self.assertTrue("refresh" in resp.data)
self.assertNotEqual(resp.data["access"], access_token)
self.assertNotEqual(resp.data["refresh"], refresh_token)
# Set the new access token
access_token = resp.data["access"]
self.client.credentials(HTTP_AUTHORIZATION=f"Bearer {access_token}")
# Check if token work and user can access request
resp = self.client.get("/api/v1/requests/" + str(r.id))
self.assertEqual(resp.status_code, status.HTTP_200_OK)
# The previous refresh token should be blacklisted
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")
