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")