def setUp(self):
setup_config()
config = NameSpace.get_config(CONFIGURATION_NAMESPACE)
AgileCardFactory(
content_item=ContentItemFactory(content_type=ContentItem.TOPIC),
recruit_project=None,
)
project_cards: List(AgileCard) = [
AgileCardFactory()
for i in range(config.REQUIRED_COMPETENT_REVIEWERS_PER_CARD + 2)
]
for n, card in enumerate(project_cards):
assert card.assignees.count()
for i in range(n):
card.add_collaborator(UserFactory(),
add_as_project_reviewer=True)
self.project_cards_needing_review = [
o for o in project_cards if
o.reviewers.count() < config.REQUIRED_COMPETENT_REVIEWERS_PER_CARD
]
self.assertGreater(len(self.project_cards_needing_review), 0)
def test_cards_in_the_review_column_waiting_for_a_review(self):
# Two cards in the IN_REVIEW column
content_item_3 = ContentItemFactory(
content_type=ContentItem.TOPIC,
project_submission_type=ContentItem.REPOSITORY,
)
card_3 = AgileCardFactory(
content_item=content_item_3,
status=AgileCard.IN_REVIEW,
recruit_project=None,
)
card_4 = AgileCardFactory(
content_item=content_item_3,
status=AgileCard.IN_REVIEW,
recruit_project=None,
)
assigned_person = SocialProfileFactory().user
card_3.assignees.set([assigned_person])
card_4.assignees.set([assigned_person])
# We should get two cards in the review column waiting for a review
self.assertEqual(
self.stats_serializer.get_cards_in_review_column_as_assignee(
user=assigned_person), 2)
def test_multiple_tilde_reviews_done(self):
user = UserFactory()
# add a review
review1 = RecruitProjectReviewFactory(timestamp=self.yesterday,
reviewer_user=user)
review1.timestamp = self.yesterday
review1.save()
AgileCardFactory(recruit_project=review1.recruit_project)
# add really old review
review2 = RecruitProjectReviewFactory(timestamp=self.two_weeks_ago,
reviewer_user=user)
review2.timestamp = self.two_weeks_ago
review2.save()
AgileCardFactory(recruit_project=review2.recruit_project)
# add a topic review, now we should have 3 reviews
review3 = TopicReviewFactory(timestamp=self.yesterday,
reviewer_user=user)
review3.timestamp = self.yesterday
review3.save()
AgileCardFactory(topic_progress=review3.topic_progress)
count = self.stats_serializer.get_total_tilde_reviews_done(user)
self.assertEqual(count, 3)
def test_multiple_tilde_reviews_done_in_last_7_days(self):
user = UserFactory()
# add a review within the right timeframe
review1 = RecruitProjectReviewFactory(timestamp=self.yesterday,
reviewer_user=user)
review1.timestamp = self.yesterday
review1.save()
AgileCardFactory(recruit_project=review1.recruit_project)
# add another review, now the number of cards reviewed is 2
review2 = RecruitProjectReviewFactory(timestamp=self.yesterday,
reviewer_user=user)
review2.timestamp = self.yesterday
review2.save()
AgileCardFactory(recruit_project=review2.recruit_project)
# add a topic review, now the number of cards reviewed is 3
review3 = TopicReviewFactory(timestamp=self.yesterday,
reviewer_user=user)
review3.timestamp = self.yesterday
review3.save()
AgileCardFactory(topic_progress=review3.topic_progress)
count = self.stats_serializer.get_tilde_reviews_done_last_7_days(user)
self.assertEqual(count, 3)
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_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_get_tilde_cards_reviewed_in_last_7_days(self):
user = UserFactory()
serializer = self.serializer
# no reviews done yet
count = self.stats_serializer.get_tilde_cards_reviewed_in_last_7_days(
user)
self.assertEqual(count, 0)
# add a review, but it's too old to count
review1 = RecruitProjectReviewFactory(timestamp=self.two_weeks_ago,
reviewer_user=user)
review1.timestamp = self.two_weeks_ago
review1.save()
AgileCardFactory(recruit_project=review1.recruit_project)
count = self.stats_serializer.get_tilde_cards_reviewed_in_last_7_days(
user)
self.assertEqual(count, 0)
# add a review within the right timeframe
review2 = RecruitProjectReviewFactory(timestamp=self.yesterday,
reviewer_user=user)
review2.timestamp = self.yesterday
review2.save()
AgileCardFactory(recruit_project=review2.recruit_project)
# assert review.reviewer_user == user
count = self.stats_serializer.get_tilde_cards_reviewed_in_last_7_days(
user)
self.assertEqual(count, 1)
# add another review on the same card, so now the number of cards reviewed is still 1
review3 = RecruitProjectReviewFactory(
timestamp=self.yesterday,
reviewer_user=user,
recruit_project=review2.recruit_project,
)
review3.timestamp = self.yesterday
review3.save()
# AgileCardFactory(recruit_project=review3.recruit_project)
count = self.stats_serializer.get_tilde_cards_reviewed_in_last_7_days(
user)
self.assertEqual(count, 1)
# add another review, now the number of cards reviewed is 2
review4 = RecruitProjectReviewFactory(timestamp=self.yesterday,
reviewer_user=user)
review4.timestamp = self.yesterday
review4.save()
AgileCardFactory(recruit_project=review4.recruit_project)
count = self.stats_serializer.get_tilde_cards_reviewed_in_last_7_days(
user)
self.assertEqual(count, 2)
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)
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 setUp(self):
self.card_1 = AgileCardFactory(status=AgileCard.IN_PROGRESS, )
self.project_1 = self.card_1.recruit_project
self.user = self.card_1.assignees.first()
self.project_1.start_time = timezone.now() - timedelta(days=5)
self.project_1.save()
self.stats_serializer = UserStatsPerWeekSerializer()
# Will use this repo card, PR, today, yesterday, two_days_before_yesterday and two_weeks_ago later on
# in test 'test_pr_reviews_card_in_different_column_due_to_review_status'.
self.today = timezone.now()
self.yesterday = self.today - timezone.timedelta(days=1)
self.two_days_before_yesterday = self.today - timezone.timedelta(
days=3)
self.two_weeks_ago = self.today - timezone.timedelta(days=14)
self.repo_card_one = factories.AgileCardFactory(
status=AgileCard.IN_PROGRESS)
self.repo_card_one.recruit_project.repository = (
git_real_factories.RepositoryFactory())
self.repo_card_one.save()
self.pull_request = git_real_factories.PullRequestFactory(
repository=self.repo_card_one.recruit_project.repository,
updated_at=self.today,
)
self.pull_request.save()
def test_one_card_in_complete_column(self):
content_item_2 = ContentItemFactory(
content_type=ContentItem.TOPIC,
project_submission_type=ContentItem.REPOSITORY,
)
card_2 = AgileCardFactory(
content_item=content_item_2,
status=AgileCard.COMPLETE,
)
assigned_person = SocialProfileFactory().user
card_2.assignees.set([assigned_person])
# We should have at least one card in the completed column and since it went there within the last seven days
# the function 'get_cards_completed_last_7_days_as_assignee' should also return at least one card
self.assertEqual(
UserDetailedStatsSerializer.
get_cards_assigned_with_status_complete(
UserDetailedStatsSerializer, user=assigned_person),
1,
)
self.assertEqual(
UserDetailedStatsSerializer.
get_cards_completed_last_7_days_as_assignee(
UserDetailedStatsSerializer, user=assigned_person),
1,
)
def test_no_tilde_reviews_done_in_last_7_days(self):
user = UserFactory()
# add a review, but it's too old to count
review = RecruitProjectReviewFactory(timestamp=self.two_weeks_ago,
reviewer_user=user)
review.timestamp = self.two_weeks_ago
review.save()
AgileCardFactory(recruit_project=review.recruit_project)
count = self.stats_serializer.get_tilde_reviews_done_last_7_days(user)
self.assertEqual(count, 0)
def make_card(
content_type,
project_submission_type=None,
continue_from_repo=None,
topic_needs_review=False,
recruit_users=[],
reviewer_users=[],
):
assert recruit_users
assert reviewer_users
if content_type == ContentItem.PROJECT:
content_item = ContentItemFactory(
content_type=content_type,
project_submission_type=project_submission_type,
continue_from_repo=continue_from_repo,
)
recruit_project = RecruitProject.objects.create(
content_item=content_item, )
recruit_project.recruit_users.set(recruit_users)
recruit_project.reviewer_users.set(reviewer_users)
return AgileCardFactory(
content_item=content_item,
status=AgileCard.READY,
recruit_project=recruit_project,
)
else:
content_item = ContentItemFactory(
content_type=content_type,
topic_needs_review=topic_needs_review,
)
return AgileCardFactory(
content_item=content_item,
status=AgileCard.READY,
)
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_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)
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_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_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],
)
