def setUp(self): super().setUp() self.zosia = create_zosia(active=True) self.normal_1 = create_user(0) self.normal_2 = create_user(1) self.staff_1 = create_user(2, is_staff=True) self.staff_2 = create_user(3, is_staff=True)
def setUp(self): super().setUp() self.normal_1 = create_user(0) self.normal_2 = create_user(1) self.staff_1 = create_user(2, is_staff=True) self.staff_2 = create_user(3, is_staff=True) self.room_1 = create_room(111, capacity=2) self.room_2 = create_room(222, capacity=1) self.room_3 = create_room(333, capacity=3, hidden=True)
def test_volunteer_viewset_with_qsp(self, client: Client) -> None: """Test whether querying with a username provides the specific user.""" client, headers, user = setup_user_client(client) create_user(username="******") result = client.get( reverse("volunteer-list") + f"?username={user.username}", **headers) assert result.status_code == status.HTTP_200_OK assert len(result.json()["results"]) == 1 assert result.json()["results"][0]["username"] == user.username
def test_case_insensitive_list_with_filter(self, client: Client) -> None: """Verify that listing all volunteers really works correctly.""" client, headers, user = setup_user_client(client) create_user(username="******") result = client.get( reverse("volunteer-list") + "?username=a", content_type="application/json", **headers, ) assert result.status_code == status.HTTP_200_OK assert len(result.json()["results"]) == 1 assert result.json()["results"][0]["username"] == "A"
def test_create_duplicate_username(self, client: Client) -> None: """Test that no user is created when an user with the username already exists.""" client, headers, _ = setup_user_client(client) data = {"username": "******"} create_user(username=data["username"]) result = client.post( reverse("volunteer-list"), json.dumps(data), content_type="application/json", **headers, ) assert result.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY assert BlossomUser.objects.filter( username=data["username"]).count() == 1
def test_session(self, rf: RequestFactory) -> None: """Verify that session data is either kept or discarded as appropriate.""" user = create_user() add_social_auth_to_user(user) submission = create_submission( original_id=int(random.random() * 1000), content_url="http://imgur.com/aaa", title="a", ) request = rf.get( reverse("transcribe_submission", kwargs={"submission_id": submission.id}), ) SessionMiddleware().process_request(request) request.session.save() request.user = user request.session["submission_id"] = submission.id request.session["heading"] = "AAA" request.session["issues"] = ["heading_with_dashes"] request.session["transcription"] = "BBB" response = TranscribeSubmission().get(request, submission.id) assert "AAA" in response.content.decode() assert "BBB" in response.content.decode() request.session["submission_id"] = 999999 response = TranscribeSubmission().get(request, submission.id) # it should have detected that the content is for a different submission, # to the session data should no longer be there assert "AAA" not in response.content.decode() assert "BBB" not in response.content.decode()
def test_claim_already_claimed_other_user(self, client: Client) -> None: """Test a claim on a Submission already claimed by another user. This should be prevented and return an error. """ BlossomUser.objects.all().delete() client, headers, user = setup_user_client(client, id=1, username="******") other_user = create_user(id=2, username="******") submission = create_submission(claimed_by=other_user) data = {"username": user.username} result = client.patch( reverse("submission-claim", args=[submission.id]), json.dumps(data), content_type="application/json", **headers, ) assert result.status_code == status.HTTP_409_CONFLICT claimed_by = result.json() assert claimed_by["id"] == 2 assert claimed_by["username"] == "user_2" submission.refresh_from_db() assert submission.claimed_by == other_user
def test_permissions_grafeas_staff_no_api_key(self, rf: RequestFactory) -> None: """Test whether the API does not allow access to Grafeas staff without API key.""" # this should fail because they don't have an api key user = create_user(is_staff=False) request = rf.get("/") request.user = user assert not BlossomApiPermission().has_permission(request, None)
def setUp(self): super().setUp() self.normal = create_user(0) self.zosia = create_zosia() self.bus1 = create_bus(zosia=self.zosia, capacity=0) self.bus2 = create_bus(zosia=self.zosia, capacity=1) self.bus3 = create_bus(zosia=self.zosia, capacity=2)
def test_process_blacklist_with_slack_link() -> None: """Verify that messages with links in them are processed correctly.""" slack_client.chat_postMessage = MagicMock() test_user = create_user() assert test_user.blacklisted is False message = f"blacklist <https://reddit.com/example|{test_user.username}>" blacklist_cmd("", message) test_user.refresh_from_db() assert test_user.blacklisted is True
def makeUserPrefsForm(self, **override): self.normal = create_user(0) defaults = { 'contact': 'fb: me', 'shirt_size': 'S', 'shirt_type': 'f', 'terms_accepted': True } defaults.update(**override) return UserPreferencesForm(self.normal, defaults)
def test_process_coc_reset_with_slack_link() -> None: """Verify that messages with links in them are processed correctly.""" slack_client.chat_postMessage = MagicMock() test_user = create_user() assert test_user.accepted_coc is True message = f"reset <https://reddit.com/example|{test_user.username}>" reset_cmd("", message) slack_client.chat_postMessage.assert_called_once() test_user.refresh_from_db() assert test_user.accepted_coc is False
def test_active_volunteer_count(client: Client) -> None: """Test whether the summary provides a correct active volunteer count.""" client, headers, user_1 = setup_user_client(client, id=123, username="******") user_2 = create_user(id=456, username="******") user_3 = create_user(id=789, username="******") now = datetime.datetime.now(tz=pytz.utc) two_days_ago = now - datetime.timedelta(days=2) one_week_ago = now - datetime.timedelta(weeks=1) three_weeks_ago = now - datetime.timedelta(weeks=3) four_weeks_ago = now - datetime.timedelta(weeks=4) create_submission(completed_by=user_1, complete_time=two_days_ago) create_submission(completed_by=user_1, complete_time=four_weeks_ago) create_submission(completed_by=user_2, complete_time=three_weeks_ago) create_submission(completed_by=user_3, complete_time=one_week_ago) result = client.get(reverse("summary"), content_type="application/json", **headers,) assert result.status_code == status.HTTP_200_OK assert result.json()["active_volunteer_count"] == 2
def test_list(self, client: Client) -> None: """Verify that getting the list of users works correctly.""" BlossomUser.objects.all().delete( ) # clear out system accounts for test client, headers, user = setup_user_client(client) result = client.get(reverse("volunteer-list"), content_type="application/json", **headers) assert result.status_code == status.HTTP_200_OK assert result.json()["count"] == 1 assert result.json()["results"][0]["username"] == user.username create_user(email="*****@*****.**", username="******") result = client.get(reverse("volunteer-list"), content_type="application/json", **headers) assert result.status_code == status.HTTP_200_OK assert result.json()["count"] == 2 assert result.json()["results"][1]["username"] == "AAA"
def test_process_unwatch_error(message: str, response: str) -> None: """Test watch command for invalid messages.""" slack_client.chat_postMessage = MagicMock() test_user = create_user(username="******") assert test_user.overwrite_check_percentage is None # process the message unwatch_cmd("", message) slack_client.chat_postMessage.assert_called_once() test_user.refresh_from_db() assert test_user.overwrite_check_percentage is None assert slack_client.chat_postMessage.call_args[1]["text"] == response
def test_permissions_override_api_auth(self, rf: RequestFactory, settings: SettingsWrapper) -> None: """Test whether the API does allow superusers without API key access.""" # first, verify that access is denied user = create_user(is_staff=False, is_grafeas_staff=False) request = rf.get("/") request.user = user assert not BlossomApiPermission().has_permission(request, None) # now make sure it works with the flag toggled on settings.OVERRIDE_API_AUTH = True request = rf.get("/") request.user = user assert BlossomApiPermission().has_permission(request, None)
def test_done_different_claim(self, client: Client) -> None: """Test whether a done with a claim from another user is caught correctly.""" client, headers, user = setup_user_client(client) claiming_user = create_user(username="******") submission = create_submission(claimed_by=claiming_user) data = {"username": user.username} result = client.patch( reverse("submission-done", args=[submission.id]), json.dumps(data), content_type="application/json", **headers, ) assert result.status_code == status.HTTP_412_PRECONDITION_FAILED
def test_find_completed(client: Client, url: str, expected: bool) -> None: """Verify that a completed posts can be found by its URLs.""" client, headers, user = setup_user_client(client, id=123, username="******") submission = create_submission( claimed_by=user, completed_by=user, url="https://reddit.com/r/antiwork/comments/q1tlcf/work_is_work/", tor_url= "https://reddit.com/r/TranscribersOfReddit/comments/q1tnhc/antiwork_image_work_is_work/", content_url="https://i.redd.it/upwchc4bqhr71.jpg", title="Work is work", ) transcription = create_transcription( id=555, submission=submission, user=user, url="https://reddit.com/r/antiwork/comments/q1tlcf/comment/hfgp814/", ) ocr_bot = create_user(id=333, username="******", is_bot=True) ocr = create_transcription( id=666, submission=submission, user=ocr_bot, url= "https://www.reddit.com/r/TranscribersOfReddit/comments/q1tnhc/comment/hfgp1gt/", ) result = client.get( reverse("find") + f"?url={url}", content_type="application/json", **headers, ) if expected: assert result.status_code == status.HTTP_200_OK actual = result.json() assert actual["submission"]["id"] == submission.id assert actual["author"]["id"] == user.id assert actual["transcription"]["id"] == transcription.id assert actual["ocr"]["id"] == ocr.id else: assert result.status_code == status.HTTP_404_NOT_FOUND
def test_process_unwatch() -> None: """Test unwatch functionality.""" slack_client.chat_postMessage = MagicMock() test_user = create_user(username="******", overwrite_check_percentage=0.5) assert test_user.overwrite_check_percentage == 0.5 # process the message unwatch_cmd("", "unwatch u123") slack_client.chat_postMessage.assert_called_once() test_user.refresh_from_db() expected_message = i18n["slack"]["unwatch"]["success"].format( user=test_user.username) assert test_user.overwrite_check_percentage is None assert slack_client.chat_postMessage.call_args[1][ "text"] == expected_message
def test_unclaim_different_user(self, client: Client) -> None: """Test whether an unclaim of a submission claimed by another user is caught.""" client, headers, user = setup_user_client(client) claiming_user = create_user(username="******") submission = create_submission(claimed_by=claiming_user) result = client.patch( reverse("submission-unclaim", args=[submission.id]), json.dumps({"username": user.username}), content_type="application/json", **headers, ) submission.refresh_from_db() assert result.status_code == status.HTTP_406_NOT_ACCEPTABLE assert submission.claimed_by == claiming_user
def test_process_watch(message: str, percentage: float) -> None: """Test watch functionality.""" slack_client.chat_postMessage = MagicMock() test_user = create_user(username="******") assert test_user.overwrite_check_percentage is None # process the message watch_cmd("", message) slack_client.chat_postMessage.assert_called_once() test_user.refresh_from_db() expected_message = i18n["slack"]["watch"]["success"].format( user=test_user.username, percentage=percentage) assert test_user.overwrite_check_percentage == percentage assert slack_client.chat_postMessage.call_args[1][ "text"] == expected_message
def test_find_by_submission_url(client: Client, url: str, url_type: str, expected: bool) -> None: """Verify that a submission is found by its submission URL.""" client, headers, user = setup_user_client(client, id=123, username="******") submission = create_submission( claimed_by=user, completed_by=user, url="https://reddit.com/r/antiwork/comments/q1tlcf/work_is_work/", tor_url= "https://reddit.com/r/TranscribersOfReddit/comments/q1tnhc/antiwork_image_work_is_work/", content_url="https://i.redd.it/upwchc4bqhr71.jpg", title="Work is work", ) transcription = create_transcription( id=555, submission=submission, user=user, url="https://reddit.com/r/antiwork/comments/q1tlcf/comment/hfgp814/", ) ocr_bot = create_user(id=333, username="******", is_bot=True) ocr = create_transcription( id=666, submission=submission, user=ocr_bot, url= "https://www.reddit.com/r/TranscribersOfReddit/comments/q1tnhc/comment/hfgp1gt/", ) actual = find_by_submission_url(url, url_type) if expected: assert actual is not None assert actual["submission"] == submission assert actual["author"] == user assert actual["transcription"] == transcription assert actual["ocr"] == ocr else: assert actual is None
def setUp(self): time = now() place = Place.objects.create(name="Mieszko", address="foo") self.zosia = Zosia.objects.create( start_date=timedelta_since_now(days=1), active=True, place=place, price_accommodation=23, registration_end=time, registration_start=time, rooming_start=time, rooming_end=time, price_transport=0, lecture_registration_start=time, lecture_registration_end=time, price_accommodation_dinner=0, price_accommodation_breakfast=0, price_whole_day=0) self.user = create_user(0)
def test_process_blacklist() -> None: """Test blacklist functionality and ensure that it works in reverse.""" slack_client.chat_postMessage = MagicMock() test_user = create_user() assert test_user.blacklisted is False message = f"blacklist {test_user.username}" blacklist_cmd("", message) slack_client.chat_postMessage.assert_called_once() test_user.refresh_from_db() assert test_user.blacklisted is True assert slack_client.chat_postMessage.call_args[1]["text"] == i18n["slack"][ "blacklist"]["success"].format(test_user.username) # Now we unblacklist them blacklist_cmd("", message) assert slack_client.chat_postMessage.call_count == 2 test_user.refresh_from_db() assert test_user.blacklisted is False assert slack_client.chat_postMessage.call_args[1]["text"] == i18n["slack"][ "blacklist"]["success_undo"].format(test_user.username)
def test_active_volunteer_count_aggregation(client: Client) -> None: """Test whether the active volunteer count is aggregated correctly. Multiple transcriptions from the same user should only count as one volunteer. """ client, headers, user_1 = setup_user_client(client, id=123, username="******") user_2 = create_user(id=456, username="******") now = datetime.datetime.now(tz=pytz.utc) two_days_ago = now - datetime.timedelta(days=2) three_weeks_ago = now - datetime.timedelta(weeks=3) create_submission(completed_by=user_1, complete_time=two_days_ago) create_submission(completed_by=user_1, complete_time=two_days_ago) create_submission(completed_by=user_1, complete_time=two_days_ago) create_submission(completed_by=user_1, complete_time=three_weeks_ago) create_submission(completed_by=user_2, complete_time=two_days_ago) result = client.get(reverse("summary"), content_type="application/json", **headers,) assert result.status_code == status.HTTP_200_OK assert result.json()["active_volunteer_count"] == 2
def test_list_with_filters(self, client: Client) -> None: """Verify that listing all volunteers works correctly.""" BlossomUser.objects.all().delete( ) # clear out system accounts for test client, headers, user = setup_user_client(client) create_user(username="******") create_user(username="******") create_user(username="******") create_user(username="******") result = client.get(reverse("volunteer-list"), content_type="application/json", **headers) assert result.status_code == status.HTTP_200_OK assert len(result.json()["results"]) == 5 result = client.get( reverse("volunteer-list") + "?username=C", content_type="application/json", **headers, ) assert result.status_code == status.HTTP_200_OK assert len(result.json()["results"]) == 1 assert result.json()["results"][0]["username"] == "C" result = client.get( reverse("volunteer-list") + "?username=C&id=1", content_type="application/json", **headers, ) assert result.status_code == status.HTTP_200_OK assert len(result.json()["results"]) == 0
def test_process_coc_reset() -> None: """Test reset functionality and ensure that it works in reverse.""" slack_client.chat_postMessage = MagicMock() test_user = create_user() assert test_user.accepted_coc is True message = f"reset {test_user.username}" # revoke their code of conduct acceptance reset_cmd("", message) slack_client.chat_postMessage.assert_called_once() test_user.refresh_from_db() assert test_user.accepted_coc is False assert slack_client.chat_postMessage.call_args[1]["text"] == i18n["slack"][ "reset_coc"]["success"].format(test_user.username) # Now we approve them reset_cmd("", message) assert slack_client.chat_postMessage.call_count == 2 test_user.refresh_from_db() assert test_user.accepted_coc is True assert slack_client.chat_postMessage.call_args[1]["text"] == i18n["slack"][ "reset_coc"]["success_undo"].format(test_user.username)
def test_user_leaderboard( self, client: Client, data: List[UserData], user_id: int, expected_above: List[int], expected_user: UserData, expected_below: List[int], ) -> None: """Test if the user related leaderboard is set up correctly.""" BlossomUser.objects.all().delete() client, headers, _ = setup_user_client(client, id=99999, is_volunteer=False) for obj in data: cur_user_id = obj.get("id") date_joined = make_aware(obj.get("date_joined", datetime.now())) cur_user = create_user( id=cur_user_id, username=f"user-{cur_user_id}", is_volunteer=True, date_joined=date_joined, ) for _ in range(obj.get("gamma")): create_submission(completed_by=cur_user) results = client.get( reverse("submission-leaderboard") + f"?user_id={user_id}", content_type="application/json", **headers, ) assert results.status_code == status.HTTP_200_OK results = results.json() assert results["user"] == expected_user assert extract_ids(results["above"]) == expected_above assert extract_ids(results["below"]) == expected_below
def test_top_leaderboard( self, client: Client, data: List[UserData], expected: List[UserData], ) -> None: """Test if the top leaderboard is set up correctly.""" BlossomUser.objects.all().delete() client, headers, _ = setup_user_client(client, id=99999, is_volunteer=False) for obj in data: user_id = obj.get("id") cur_user = create_user( id=user_id, username=f"user-{user_id}", is_volunteer=True, ) for _ in range(obj.get("gamma")): create_submission(completed_by=cur_user) result = client.get( reverse("submission-leaderboard"), content_type="application/json", **headers, ) assert result.status_code == status.HTTP_200_OK actual = extract_ids(result.json()["top"]) assert actual == expected
def setUp(self): super().setUp() self.normal_1 = create_user(0) self.normal_2 = create_user(1)