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)
