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_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(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_blacklist(self):
team = TeamFactory(name="tghyj TechQuest dfghj")
review = RecruitProjectReviewFactory(
reviewer_user=self.user_1, validated=RecruitProjectReview.CORRECT)
assignee = review.recruit_project.recruit_users.first()
team.user_set.add(assignee)
self.assertEqual(review.get_validated_streak(), 0)
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 test_no_card_in_completed_column_after_untrusted_competent_review(
self):
time_two = self.project_1.start_time + timedelta(days=4)
review_2 = RecruitProjectReviewFactory(
status=COMPETENT,
recruit_project=self.project_1,
)
review_2.timestamp = time_two
review_2.save()
# review_2 had a status of COMPETENT, the reviewer is not trusted and therefore we should have zero cards in
# the completed column
self.assertEqual(
self.stats_serializer.get_cards_in_complete_column_as_assignee(
user=self.user), 0)
def test_one_card_in_review_feedback_column(self):
# Request for a review to happen on project_1, card_1
request_review_time = self.project_1.start_time + timedelta(1)
time_one = self.project_1.start_time - timedelta(days=6)
self.project_1.request_review(force_timestamp=request_review_time)
review_1 = RecruitProjectReviewFactory(status=NOT_YET_COMPETENT,
recruit_project=self.project_1,
timestamp=time_one)
review_1.timestamp = time_one
review_1.save()
# review_1 had a status of NYC, so we should have at least one card in the 'REVIEW FEEDBACK' column
self.assertEqual(
self.stats_serializer.
get_cards_in_review_feedback_column_as_assignee(user=self.user), 1)
def test_that_different_users_get_different_streaks(self):
review_js_1 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_js_1,
validated=RecruitProjectReview.CORRECT,
)
review_js_2 = RecruitProjectReviewFactory(
reviewer_user=self.user_2,
recruit_project=self.project_js_2,
validated=RecruitProjectReview.CORRECT,
)
self.assertEqual(review_js_1.get_validated_streak(), 1)
self.assertEqual(review_js_2.get_validated_streak(), 1)
def test_get_tilde_cards_reviewed_in_last_7_days(self):
user = UserFactory()
# 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 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 test_only_grabs_last_review_for_project(self):
"""otherwise people can try to cheat the system by adding extra reviews to the same thing"""
review_js_1 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_js_1,
validated=RecruitProjectReview.CORRECT,
)
review_js_2 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_js_1,
validated=RecruitProjectReview.CORRECT,
)
review_js_3 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_js_2,
validated=RecruitProjectReview.CORRECT,
)
review_js_4 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_js_1,
validated=RecruitProjectReview.CORRECT,
)
self.assertEqual(review_js_1.get_validated_streak(), 1)
self.assertEqual(review_js_2.get_validated_streak(), 1)
self.assertEqual(review_js_3.get_validated_streak(), 2)
self.assertEqual(review_js_4.get_validated_streak(), 2)
def test_interrupted_streak(self):
review_js_1 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_js_1,
validated=RecruitProjectReview.CORRECT,
)
review_js_2 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_js_2,
validated=RecruitProjectReview.INCORRECT,
)
review_js_3 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_js_3,
validated=RecruitProjectReview.CORRECT,
)
review_js_4 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_js_4,
validated=RecruitProjectReview.CORRECT,
)
self.assertEqual(review_js_1.get_validated_streak(), 1)
self.assertEqual(review_js_2.get_validated_streak(), 0)
self.assertEqual(review_js_3.get_validated_streak(), 1)
self.assertEqual(review_js_4.get_validated_streak(), 2)
def test_streak_adds_up_per_flavour(self):
review_js_1 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_js_1,
validated=RecruitProjectReview.CORRECT,
)
review_ts_1 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_ts_1,
validated=RecruitProjectReview.CORRECT,
)
review_js_2 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_js_2,
validated=RecruitProjectReview.CORRECT,
)
review_ts_2 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_ts_2,
validated=RecruitProjectReview.CORRECT,
)
review_js_3 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_js_3,
validated=RecruitProjectReview.CORRECT,
)
review_ts_3 = RecruitProjectReviewFactory(
reviewer_user=self.user_1,
recruit_project=self.project_ts_3,
validated=RecruitProjectReview.CORRECT,
)
self.assertEqual(review_js_1.get_validated_streak(), 1)
self.assertEqual(review_js_2.get_validated_streak(), 2)
self.assertEqual(review_js_3.get_validated_streak(), 3)
self.assertEqual(review_ts_1.get_validated_streak(), 1)
self.assertEqual(review_ts_2.get_validated_streak(), 2)
self.assertEqual(review_ts_3.get_validated_streak(), 3)
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_different_statuses(self):
review = RecruitProjectReviewFactory(reviewer_user=self.user_1, validated=None)
self.assertEqual(review.get_validated_streak(), 0)
review = RecruitProjectReviewFactory(
reviewer_user=self.user_1, validated=RecruitProjectReview.INCORRECT
)
self.assertEqual(review.get_validated_streak(), 0)
review = RecruitProjectReviewFactory(
reviewer_user=self.user_1, validated=RecruitProjectReview.CONTRADICTED
)
self.assertEqual(review.get_validated_streak(), 0)
review = RecruitProjectReviewFactory(
reviewer_user=self.user_1, validated=RecruitProjectReview.CORRECT
)
self.assertEqual(review.get_validated_streak(), 1)
