def test_that_only_competent_people_get_returned(self):
competent_project = RecruitProjectFactory(complete_time=timezone.now(),
flavours=[JAVASCRIPT])
content_item = competent_project.content_item
nyc_project = RecruitProjectFactory(complete_time=None,
flavours=[JAVASCRIPT],
content_item=content_item)
wrong_flavour_project = RecruitProjectFactory(
complete_time=timezone.now(),
flavours=[TYPESCRIPT],
content_item=content_item,
)
card = AgileCardFactory(
recruit_project=RecruitProjectFactory(
complete_time=None,
flavours=[JAVASCRIPT],
content_item=content_item,
),
status=AgileCard.IN_PROGRESS,
)
assert card.flavours_match(
card.recruit_project.flavour_names
), f"{card.flavour_names} != {card.recruit_project.flavour_names}"
result = list(get_possible_competent_reviewers(card))
self.assertEqual(result, [competent_project.recruit_users.first()])
def test(self):
user = UserFactory()
content_item = ContentItemFactory(flavours=["js"])
for i in range(CURRICULUM_TRACKING_TRUST_STREAK_LENGTH - 1):
project = RecruitProjectFactory(content_item=content_item, flavours=["js"])
RecruitProjectReviewFactory(
recruit_project=project,
reviewer_user=user,
validated=RecruitProjectReview.CORRECT,
)
trust_count = ReviewTrust.objects.all().count()
self.assertEqual(trust_count, 0)
# add one more and the user should be trusted
project = RecruitProjectFactory(content_item=content_item, flavours=["js"])
RecruitProjectReviewFactory(
recruit_project=project,
reviewer_user=user,
validated=RecruitProjectReview.CORRECT,
)
trust_count = ReviewTrust.objects.all().count()
self.assertEqual(trust_count, 1)
trust = ReviewTrust.objects.first()
self.assertEqual(trust.content_item, content_item)
self.assertEqual(trust.user, user)
self.assertTrue(trust.flavours_match(["js"]))
def test_all(self):
time_1 = timezone.now() - datetime.timedelta(days=1)
time_2 = time_1 + datetime.timedelta(hours=1)
time_3 = time_1 + datetime.timedelta(hours=2)
time_4 = time_1 + datetime.timedelta(hours=3)
project = RecruitProjectFactory()
project.review_request_time = time_2
review_1 = RecruitProjectReviewFactory(recruit_project=project,
timestamp=time_1)
review_1.timestamp = time_1
review_1.save()
review_2 = RecruitProjectReviewFactory(recruit_project=project,
timestamp=time_3)
review_2.timestamp = time_3
review_2.save()
review_3 = RecruitProjectReviewFactory(recruit_project=project,
timestamp=time_4)
review_3.timestamp = time_4
review_3.save()
# assert review_1.timestamp == time_1, review_1.timestamp
# assert project.review_request_time == time_2
# assert review_2.timestamp == time_3
# assert review_3.timestamp == time_4
# assert time_1 < time_2
# assert time_2 < time_3
# assert time_3 < time_4
self.assertFalse(review_1.is_first_review_after_request())
self.assertTrue(review_2.is_first_review_after_request())
self.assertFalse(review_3.is_first_review_after_request())
def test_updates_only_fist_one(self):
time_1 = timezone.now() - datetime.timedelta(days=1)
time_2 = time_1 + datetime.timedelta(hours=1)
time_3 = time_1 + datetime.timedelta(hours=2)
time_4 = time_1 + datetime.timedelta(hours=3)
project = RecruitProjectFactory()
project.review_request_time = time_1
review_1 = RecruitProjectReviewFactory(
recruit_project=project, timestamp=time_1, status=COMPETENT
)
review_1.timestamp = time_2
review_1.save()
review_2 = RecruitProjectReviewFactory(
recruit_project=project, timestamp=time_3, status=COMPETENT
)
review_2.timestamp = time_3
review_2.save()
review_3 = RecruitProjectReviewFactory(
recruit_project=project, timestamp=time_4, status=COMPETENT
)
review_3.timestamp = time_4
review_3.trusted = True
review_3.save()
review_3.update_recent_validation_flags_for_project()
review_1.refresh_from_db()
review_2.refresh_from_db()
review_3.refresh_from_db()
self.assertEqual(review_1.validated, RecruitProjectReview.CORRECT)
self.assertEqual(review_2.validated, None)
self.assertEqual(review_3.validated, None)
def setUp(self):
self.card = AgileCardFactory()
self.card.recruit_project.set_flavours(MATCHING_FLAVOURS)
self.card.set_flavours(MATCHING_FLAVOURS)
self.project = RecruitProjectFactory(
content_item=self.card.content_item)
self.user = self.project.recruit_users.first()
def test_bulk_set_due_date_happened_for_every_card_with_the_same_content_item_for_the_team(
self, ):
"""
Three cards, two with the same content_item and one with a different content_item. The one with the
different content_item should not have it's due_time updated, it should be left as it is.
"""
project = RecruitProjectFactory(due_time=None)
card_1 = AgileCardFactory(recruit_project=project,
flavours=["JAVASCRIPT"])
card_1.assignees.add(self.user_one_red)
card_2 = AgileCardFactory(
recruit_project=RecruitProjectFactory(due_time=None),
content_item=card_1.content_item,
flavours=["JAVASCRIPT"],
)
card_2.assignees.add(self.user_two_red)
card_3 = AgileCardFactory(
recruit_project=RecruitProjectFactory(due_time=None),
flavours=["JAVASCRIPT"],
)
card_3.assignees.add(self.user_two_red)
self.assertEqual(card_1.content_item, card_2.content_item)
self.assertNotEqual(card_1.content_item, card_3.content_item)
self.login(self.super_user)
url = f"{self.get_instance_url(pk=self.red_team.id)}bulk_set_due_dates/"
due_date = "2021-12-03T14:17"
response = self.client.post(
path=url,
format="json",
data={
"due_time": due_date,
"content_item": card_1.content_item.id,
"team": str(self.red_team.id),
"flavours": [card_1.flavours.first().id],
},
)
self.assertEqual(response.status_code, 200)
team_cards = get_team_cards(self.red_team, card_1.content_item)
self.assertIn(card_1, team_cards)
self.assertIn(card_2, team_cards)
self.assertNotIn(card_3, team_cards)
for card in team_cards:
card.refresh_from_db()
date_expected = parse_datetime(due_date).replace(
tzinfo=timezone.utc)
self.assertTrue(card.due_time, date_expected)
self.assertIsNone(card_3.due_time)
def test_super_user_can_bulk_set_due_dates_for_a_team(self):
project = RecruitProjectFactory(due_time=None)
card = AgileCardFactory(recruit_project=project,
flavours=["JAVASCRIPT", "PYTHON"])
card.reviewers.add(self.user_one_blue)
card.assignees.add(self.user_two_blue)
self.assertIsNone(card.due_time)
self.login(self.super_user)
url = f"{self.get_instance_url(pk=self.blue_team.id)}bulk_set_due_dates/"
due_date = "2021-12-03T14:17"
response = self.client.post(
path=url,
format="json",
data={
"due_time": due_date,
"content_item": card.content_item.id,
"team": str(self.blue_team.id),
"flavours":
[card.flavours.first().id,
card.flavours.last().id],
},
)
self.assertEqual(response.status_code, 200)
card.refresh_from_db()
date_expected = parse_datetime(due_date).replace(tzinfo=timezone.utc)
self.assertEqual(card.due_time, date_expected)
def test_that_it_works_with_flavourless_projects(self):
competent_project = RecruitProjectFactory(complete_time=timezone.now(),
flavours=[])
content_item = competent_project.content_item
nyc_project = RecruitProjectFactory(complete_time=None,
flavours=[],
content_item=content_item)
wrong_flavour_project = RecruitProjectFactory(
complete_time=timezone.now(),
flavours=[TYPESCRIPT],
content_item=content_item,
)
card = AgileCardFactory(recruit_project=RecruitProjectFactory(
complete_time=None, flavours=[], content_item=content_item))
result = list(get_possible_competent_reviewers(card))
self.assertEqual(result, [competent_project.recruit_users.first()])
def test_multiple_projects_submitted(self):
team = TeamFactory()
project1 = RecruitProjectFactory(link_submission='https://i_am_a_link')
link1 = project1.link_submission
user1 = project1.recruit_users.first()
team.users.add(user1)
project2 = RecruitProjectFactory(
link_submission='https://i_am_another_link',
content_item=project1.content_item)
link2 = project2.link_submission
user2 = project2.recruit_users.first()
team.users.add(user2)
results = get_user_and_projectlink(team, project1.content_item)
self.assertEqual(results[0], [user1.email, link1])
self.assertEqual(results[1], [user2.email, link2])
def setUp(self):
content_item = ContentItemFactory()
self.project_js_1 = RecruitProjectFactory(
flavours=["js"], content_item=content_item
)
self.project_js_2 = RecruitProjectFactory(
flavours=["js"], content_item=content_item
)
self.project_js_3 = RecruitProjectFactory(
flavours=["js"], content_item=content_item
)
self.project_js_4 = RecruitProjectFactory(
flavours=["js"], content_item=content_item
)
self.project_ts_1 = RecruitProjectFactory(
flavours=["ts"], content_item=content_item
)
self.project_ts_2 = RecruitProjectFactory(
flavours=["ts"], content_item=content_item
)
self.project_ts_3 = RecruitProjectFactory(
flavours=["ts"], content_item=content_item
)
self.user_1 = UserFactory()
self.user_2 = UserFactory()
def test_project_submitted(self):
team = TeamFactory()
project = RecruitProjectFactory(link_submission='https://i_am_a_link')
link = project.link_submission
user = project.recruit_users.first()
team.users.add(user)
result = get_user_and_projectlink(team, project.content_item)
self.assertEqual(result[0], [user.email, link])
def test_due_date_not_set_if_flavour_name_differs_to_request(self):
"""
Three cards (1 'js' flavour & 2 'python' flavoured); the request is for team_cards with a 'js' flavour to have
their due dates set and all other flavoured cards to not have their due dates altered.
"""
project = RecruitProjectFactory(due_time=None)
card_1 = AgileCardFactory(recruit_project=project,
flavours=["JAVASCRIPT"])
card_1.assignees.add(self.user_one_red)
card_2 = AgileCardFactory(
recruit_project=RecruitProjectFactory(due_time=None),
content_item=card_1.content_item,
flavours=["PYTHON"],
)
card_2.assignees.add(self.user_two_red)
card_3 = AgileCardFactory(
recruit_project=RecruitProjectFactory(due_time=None),
content_item=card_1.content_item,
flavours=["PYTHON"],
)
card_3.assignees.add(self.user_two_red)
self.assertEqual(card_1.content_item, card_2.content_item)
self.assertEqual(card_1.content_item, card_3.content_item)
self.login(self.super_user)
url = f"{self.get_instance_url(pk=self.red_team.id)}bulk_set_due_dates/"
due_date = "2022-01-20T12:17"
response = self.client.post(
path=url,
format="json",
data={
"due_time": due_date,
"content_item": card_1.content_item.id,
"flavours": [card_1.flavours.first().id],
},
)
self.assertEqual(response.status_code, 200)
card_1.refresh_from_db()
card_2.refresh_from_db()
card_3.refresh_from_db()
date_expected = parse_datetime(due_date).replace(tzinfo=timezone.utc)
self.assertEqual(card_1.due_time, date_expected)
self.assertIsNone(card_2.due_time)
self.assertIsNone(card_3.due_time)
def test_that_only_competent_people_get_returned(self):
config = NameSpace.get_config(CONFIGURATION_NAMESPACE)
competent_project = RecruitProjectFactory(complete_time=timezone.now(),
flavours=[JAVASCRIPT])
content_item = competent_project.content_item
card = AgileCardFactory(
recruit_project=RecruitProjectFactory(
complete_time=None,
flavours=[JAVASCRIPT],
content_item=content_item,
),
status=AgileCard.IN_PROGRESS,
)
team = TeamFactory(
name=config.EXCLUDE_TEAMS_FROM_COMPETENT_REVIEW_STEP[0])
team.user_set.add(competent_project.recruit_users.first())
result = list(get_possible_competent_reviewers(card))
self.assertEqual(result, [])
def test_team_members_cannot_bulk_set_due_dates_for_the_team_they_belong_to(
self):
project = RecruitProjectFactory(due_time=None)
card = AgileCardFactory(recruit_project=project)
card.reviewers.add(self.user_one_red)
card.assignees.add(self.user_two_red)
self.login(self.user_two_red)
url = f"{self.get_instance_url(pk=self.red_team.id)}bulk_set_due_dates/"
response = self.client.post(
path=url,
format="json",
data={
"due_time": "2021-12-03T14:17",
"content_item": card.content_item.id,
"flavours": [1, 2, 3],
},
)
self.assertEqual(response.status_code, 404)
class user_is_competent_for_card_project_Test(TestCase):
def setUp(self):
self.card = AgileCardFactory()
self.card.recruit_project.set_flavours(MATCHING_FLAVOURS)
self.card.set_flavours(MATCHING_FLAVOURS)
self.project = RecruitProjectFactory(
content_item=self.card.content_item)
self.user = self.project.recruit_users.first()
def test_is_competent_with_flavours(self):
self.project.set_flavours(MATCHING_FLAVOURS)
self.project.complete_time = timezone.now()
self.project.save()
self.assertTrue(
user_is_competent_for_card_project(card=self.card, user=self.user))
def test_is_competent_with_no_flavours(self):
self.project.set_flavours([])
self.card.recruit_project.set_flavours([])
self.card.set_flavours([])
self.project.complete_time = timezone.now()
self.project.save()
self.assertTrue(
user_is_competent_for_card_project(card=self.card, user=self.user))
def test_is_not_competent_because_not_complete(self):
self.project.set_flavours(MATCHING_FLAVOURS)
self.project.complete_time = None
self.project.save()
self.assertFalse(
user_is_competent_for_card_project(card=self.card, user=self.user))
def test_is_not_competent_because_flavour_mismatch(self):
self.project.set_flavours([])
self.project.complete_time = timezone.now()
self.project.save()
self.assertFalse(
user_is_competent_for_card_project(card=self.card, user=self.user))
def test_that_users_with_no_project_not_competent(self):
self.assertFalse(
user_is_competent_for_card_project(card=self.card,
user=UserFactory()))
def test_that_reviewers_returned_in_order(self):
content_item = ContentItemFactory()
competent_projects = [
RecruitProjectFactory(complete_time=timezone.now(),
flavours=[],
content_item=content_item) for i in range(3)
]
for n, project in enumerate(competent_projects):
reviews_to_add = 5 - n
for i in range(reviews_to_add):
nyc_card = AgileCardFactory(
status=AgileCard.IN_PROGRESS,
recruit_project=RecruitProjectFactory(
complete_time=None,
flavours=[],
content_item=content_item),
)
project_user = project.recruit_users.first()
nyc_card.reviewers.add(project_user)
nyc_card.recruit_project.reviewer_users.add(project_user)
card = AgileCardFactory(
status=AgileCard.IN_PROGRESS,
recruit_project=RecruitProjectFactory(complete_time=None,
flavours=[],
content_item=content_item),
)
expected_result = [
project.recruit_users.first()
for project in competent_projects[::-1]
]
assert expected_result
result = list(get_possible_competent_reviewers(card))
self.assertEqual(
result,
expected_result,
)
# add some more duties to first person and make sure order is still correct
project_user = expected_result[0]
for i in range(5):
nyc_card = AgileCardFactory(
status=AgileCard.IN_PROGRESS,
recruit_project=RecruitProjectFactory(
complete_time=None, flavours=[],
content_item=content_item),
)
nyc_card.reviewers.add(project_user)
nyc_card.recruit_project.reviewer_users.add(project_user)
expected_result = expected_result[1:] + [expected_result[0]]
result = list(get_possible_competent_reviewers(card))
self.assertEqual(
result,
expected_result,
)
# test_that_if_a_user_is_already_a_reviewer_they_are_skipped(self)
card.reviewers.add(expected_result[0])
card.recruit_project.reviewer_users.add(expected_result[0])
card.reviewers.add(expected_result[-1])
card.recruit_project.reviewer_users.add(expected_result[-1])
result = list(get_possible_competent_reviewers(card))
self.assertEqual(
result,
expected_result[1:-1],
)
