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