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(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 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_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 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_log_topic_competence_review_envoked_creates_log_entries(self):
super_user = UserFactory(is_superuser=True)
card = AgileCardFactory(content_item=ContentItemFactory())
card.topic_progress = TopicProgressFactory()
card.save()
self.login(super_user)
response = self.client.post(
path=f"{self.get_instance_url(pk=card.id)}add_review/",
data={
"status": NOT_YET_COMPETENT,
"comments": "dammit"
},
)
self.assertTrue(response.status_code, 200)
topic_review = TopicReview.objects.first()
log_entry = LogEntry.objects.first()
self.assertEqual(log_entry.actor_user, topic_review.reviewer_user)
self.assertEqual(log_entry.timestamp, topic_review.timestamp)
def test_log_topic_competence_review_envoked(
self, log_project_competence_review_done,
log_topic_competence_review_done):
super_user = UserFactory(is_superuser=True)
card = AgileCardFactory(content_item=ContentItemFactory())
card.topic_progress = TopicProgressFactory()
card.save()
self.login(super_user)
response = self.client.post(
path=f"{self.get_instance_url(pk=card.id)}add_review/",
data={
"status": NOT_YET_COMPETENT,
"comments": "dammit"
},
)
topic_review = TopicReview.objects.first()
self.assertTrue(response.status_code, 200)
log_topic_competence_review_done.assert_called_with(topic_review)
log_project_competence_review_done.assert_not_called()
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],
)