class ChallengeTest(TestCase):
def setUp(self):
self.create_test_users(4)
self.create_course()
self.create_stack()
self.create_challenge()
self.create_review_question()
def create_test_user(self, username):
user = AuroraUser(username=username)
user.email = '%[email protected].' % username
user.first_name = 'Firstname_%s' % username
user.last_name = 'Lastname_%s' % username
user.nickname = 'Nickname_%s' % username
user.is_staff = False
user.is_superuser = False
password = username
user.set_password(password)
user.save()
return user
def create_test_users(self, amount):
self.users = []
for i in range(amount):
self.users.append(self.create_test_user("s%s" % i))
def create_course(self):
self.course = Course(
title='test_title',
short_title='test_short_title',
description='test_description',
course_number='test_course_number',
)
self.course.save()
for user in self.users:
CourseUserRelation(course=self.course, user=user).save()
def create_stack(self):
self.stack = Stack(title="test stack", description="test description", course=self.course)
self.stack.save()
def create_challenge(self):
self.challenge = Challenge(
title='test_title',
subtitle='test_subtitle',
description='test_description',
course=self.course,
)
self.challenge.save()
StackChallengeRelation(stack=self.stack, challenge=self.challenge).save()
def create_review_question(self):
self.review_question = ReviewQuestion(
challenge=self.challenge,
order=1,
text="Can you find any additional material not included in this submission?"
)
self.review_question.save()
def create_review(self, elaboration, reviewer):
Review(elaboration=elaboration, submission_time=datetime.now(), reviewer=reviewer, appraisal='S').save()
def test_next(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert challenge1.get_next() == challenge2
assert challenge2.get_next() == challenge3
assert challenge3.get_next() is None
def test_get_elaboration(self):
user = self.users[0]
assert self.challenge.get_elaboration(user) is None
elaboration = Elaboration(challenge=self.challenge, user=user, elaboration_text="test")
elaboration.save()
assert self.challenge.get_elaboration(user) == elaboration
def test_get_stack(self):
challenge = Challenge(
title='test_title',
subtitle='test_subtitle',
description='test_description',
course=self.course
)
challenge.save()
assert challenge.get_stack() is None
assert self.challenge.get_stack() == self.stack
def test_is_first_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert challenge1.is_first_challenge()
assert not challenge2.is_first_challenge()
assert not challenge3.is_first_challenge()
def test_is_final_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert not challenge1.is_final_challenge()
assert not challenge2.is_final_challenge()
assert challenge3.is_final_challenge()
def test_get_final_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert challenge1.get_final_challenge() == challenge3
assert challenge2.get_final_challenge() == challenge3
assert challenge3.get_final_challenge() == challenge3
def test_get_first_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert challenge1.get_first_challenge() == challenge1
assert challenge2.get_first_challenge() == challenge1
assert challenge3.get_first_challenge() == challenge1
def test_has_enough_user_reviews(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
user1 = self.users[0]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
user2 = self.users[1]
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
user3 = self.users[2]
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
user4 = self.users[3]
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert not challenge1.has_enough_user_reviews(user1)
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not challenge1.has_enough_user_reviews(user1)
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not challenge1.has_enough_user_reviews(user1)
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.has_enough_user_reviews(user1)
def test_is_started(self):
user = self.users[0]
elaboration = Elaboration(challenge=self.challenge, user=user, elaboration_text="")
elaboration.save()
assert self.challenge.is_started(user) is False
elaboration.elaboration_text="test"
elaboration.save()
assert self.challenge.is_started(user) is True
def test_submitted_by_user(self):
user = self.users[0]
elaboration = Elaboration(challenge=self.challenge, user=user, elaboration_text="test")
elaboration.save()
assert not self.challenge.submitted_by_user(user)
elaboration.submission_time = datetime.now()
elaboration.save()
assert self.challenge.submitted_by_user(user)
def test_get_review_written_by_user(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
user1 = self.users[0]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
user2 = self.users[1]
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
user3 = self.users[2]
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
user4 = self.users[3]
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert len(challenge1.get_reviews_written_by_user(user1)) == 0
review1 = Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS)
review1.save()
assert len(challenge1.get_reviews_written_by_user(user1)) == 1
assert review1 in challenge1.get_reviews_written_by_user(user1)
review2 = Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS)
review2.save()
assert len(challenge1.get_reviews_written_by_user(user1)) == 2
assert review1 in challenge1.get_reviews_written_by_user(user1)
assert review2 in challenge1.get_reviews_written_by_user(user1)
review3 = Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS)
review3.save()
assert len(challenge1.get_reviews_written_by_user(user1)) == 3
assert review1 in challenge1.get_reviews_written_by_user(user1)
assert review2 in challenge1.get_reviews_written_by_user(user1)
assert review3 in challenge1.get_reviews_written_by_user(user1)
def test_get_elaborations(self):
assert len(self.challenge.get_elaborations()) == 0
user = self.users[0]
elaboration = Elaboration(challenge=self.challenge, user=user, elaboration_text="test")
elaboration.save()
assert len(self.challenge.get_elaborations()) == 1
assert elaboration in self.challenge.get_elaborations()
def test_first_challenge_is_always_enabled(self):
user = self.users[0]
assert self.challenge.is_enabled_for_user(user)
def test_already_submitted_challenges_are_enabled(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
user = self.users[0]
assert not challenge2.is_enabled_for_user(user)
elaboration = Elaboration(challenge=challenge2, user=user, elaboration_text="test")
elaboration.save()
assert not challenge2.is_enabled_for_user(user)
elaboration.submission_time = datetime.now()
elaboration.save()
assert challenge2.is_enabled_for_user(user)
def test_enough_user_reviews_required(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert not challenge2.is_enabled_for_user(user1)
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not challenge2.is_enabled_for_user(user1)
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not challenge2.is_enabled_for_user(user1)
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge2.is_enabled_for_user(user1)
def test_if_stack_blocked_challenge_is_not_enabled_fail(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge2.is_enabled_for_user(user1)
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2, appraisal=Review.FAIL).save()
# a failed review does not block the stack
assert challenge2.is_enabled_for_user(user1)
def test_if_stack_blocked_challenge_is_not_enabled_nothing(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge2.is_enabled_for_user(user1)
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.NOTHING).save()
# nothing should not block a user from working
assert challenge2.is_enabled_for_user(user1)
def test_final_challenge_enabled(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not challenge2.is_enabled_for_user(user1)
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user3,
appraisal=Review.SUCCESS).save()
assert challenge2.is_enabled_for_user(user1)
def test_final_challenge_enabled_bug_issue_114(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not challenge3.is_enabled_for_user(user1)
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user3,
appraisal=Review.SUCCESS).save()
assert not challenge3.is_enabled_for_user(user1)
def test_status_not_started(self):
user = self.users[0]
assert self.challenge.is_enabled_for_user(user)
assert self.challenge.get_status(user) == Challenge.NOT_STARTED
def test_status_not_submitted(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
user = self.users[0]
assert challenge1.get_status(user) == Challenge.NOT_STARTED
elaboration = Elaboration(challenge=challenge1, user=user, elaboration_text="test")
elaboration.save()
assert challenge1.is_enabled_for_user(user)
assert challenge1.get_status(user) == Challenge.NOT_SUBMITTED
assert not challenge2.is_enabled_for_user(user)
assert challenge2.get_status(user) == Challenge.NOT_ENABLED
def test_status_blocked_bad_review_fail(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert not challenge2.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.USER_REVIEW_MISSING
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
bad_review = Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.FAIL)
bad_review.save()
assert not challenge2.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.USER_REVIEW_MISSING
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
bad_review.appraisal = Review.SUCCESS
bad_review.save()
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.has_enough_user_reviews(user1)
assert challenge1.get_status(user1) == Challenge.DONE_MISSING_PEER_REVIEW
assert challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_STARTED
bad_review.appraisal = Review.FAIL
bad_review.save()
assert challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_STARTED
def test_status_blocked_bad_review_nothing(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert not challenge2.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.USER_REVIEW_MISSING
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
bad_review = Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.NOTHING)
bad_review.save()
assert not challenge2.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.BLOCKED_BAD_REVIEW
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
bad_review.appraisal = Review.SUCCESS
bad_review.save()
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.has_enough_user_reviews(user1)
assert challenge1.get_status(user1) == Challenge.DONE_MISSING_PEER_REVIEW
assert challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_STARTED
bad_review.appraisal = Review.NOTHING
bad_review.save()
assert challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_STARTED
def test_status_user_review_missing(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert challenge1.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.USER_REVIEW_MISSING
assert not challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.USER_REVIEW_MISSING
assert not challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.USER_REVIEW_MISSING
assert not challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.DONE_MISSING_PEER_REVIEW
assert challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_STARTED
def test_status_done_missing_peer_review(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.get_status(user1) == Challenge.DONE_MISSING_PEER_REVIEW
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.SUCCESS).save()
assert challenge1.get_status(user1) == Challenge.DONE_MISSING_PEER_REVIEW
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user3,
appraisal=Review.SUCCESS).save()
assert challenge1.get_status(user1) == Challenge.DONE_MISSING_PEER_REVIEW
def test_status_final_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
user1 = self.users[0]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
user2 = self.users[1]
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
user3 = self.users[2]
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
user4 = self.users[3]
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.get_status(user1) == Challenge.DONE_MISSING_PEER_REVIEW
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user3,
appraisal=Review.SUCCESS).save()
assert challenge1.get_status(user1) == Challenge.DONE_PEER_REVIEWED
assert challenge2.get_status(user1) == Challenge.NOT_STARTED
final_elaboration = Elaboration(challenge=challenge2, user=user1, elaboration_text="test",
submission_time=datetime.now())
final_elaboration.save()
assert challenge2.get_status(user1) == Challenge.WAITING_FOR_EVALUATION
tutor = user4
tutor.staff = True
tutor.save()
Evaluation(submission=final_elaboration, tutor=tutor, evaluation_text="test evaluation", evaluation_points=10,
submission_time=datetime.now()).save()
assert challenge2.get_status(user1) == Challenge.EVALUATED
class SimpleTest(TestCase):
def setUp(self):
self.create_test_users(4)
self.create_course()
self.create_challenge()
self.create_review_question()
self.create_elaborations()
def create_test_user(self, username):
user = AuroraUser(username=username)
user.email = '%[email protected].' % username
user.first_name = 'Firstname_%s' % username
user.last_name = 'Lastname_%s' % username
user.nickname = 'Nickname_%s' % username
user.is_staff = False
user.is_superuser = False
password = username
user.set_password(password)
user.save()
return user
def create_test_users(self, amount):
self.users = []
for i in range(amount):
self.users.append(self.create_test_user("s%s" % i))
def create_course(self):
self.course = Course(
title='test_title',
short_title='test_short_title',
description='test_description',
course_number='test_course_number',
)
self.course.save()
for user in self.users:
CourseUserRelation(course=self.course, user=user).save()
def create_challenge(self):
self.challenge = Challenge(
title='test_title',
subtitle='test_subtitle',
description='test_description',
course=self.course,
)
self.challenge.save()
def create_review_question(self):
self.review_question = ReviewQuestion(
challenge=self.challenge,
order=1,
text="Can you find any additional material not included in this submission?"
)
self.review_question.save()
def create_elaborations(self):
self.elaborations = []
for user in self.users:
elaboration = Elaboration(challenge=self.challenge, user=user, elaboration_text="test_text",
submission_time=datetime.now())
elaboration.save()
self.elaborations.append(elaboration)
def create_review_without_submission_date(self, elaboration, reviewer):
Review(elaboration=elaboration, reviewer=reviewer, appraisal='S').save()
def create_review(self, elaboration, reviewer):
Review(elaboration=elaboration, reviewer=reviewer, submission_time=datetime.now(), appraisal='S').save()
def test_get_open_review(self):
user1 = self.users[0]
user2 = self.users[2]
elaboration = self.elaborations[0]
self.create_review_without_submission_date(elaboration=elaboration, reviewer=user1)
# there should be an open review for user1
review = Review.get_open_review(self.challenge, user1)
assert review
assert review.reviewer == user1
assert review.elaboration == elaboration
# there should be no open review for user1 since the review is already submitted
review.submission_time = datetime.now()
review.save()
review = Review.get_open_review(self.challenge, user1)
assert not review
# there should be no open review for user2
review = Review.get_open_review(self.challenge, user2)
assert not review
# user1 and user2 both have separate open reviews
self.create_review_without_submission_date(elaboration=elaboration, reviewer=user1)
self.create_review_without_submission_date(elaboration=elaboration, reviewer=user2)
review1 = Review.get_open_review(self.challenge, user1)
review2 = Review.get_open_review(self.challenge, user2)
assert review1
assert review2
assert review1.id != review2.id
assert review1.reviewer == user1
assert review2.reviewer == user2
assert review1.elaboration == elaboration and review2.elaboration == elaboration
def test_review_config_offset(self):
assert ReviewConfig.get_candidate_offset_min() == 0
assert ReviewConfig.get_candidate_offset_max() == 0
ReviewConfig(candidate_offset_min=1, candidate_offset_max=2).save()
assert ReviewConfig.get_candidate_offset_min() == 1
assert ReviewConfig.get_candidate_offset_max() == 2
def test_notification_too_soon(self):
challenge1 = self.challenge
challenge2 = Challenge(
course=self.course,
prerequisite=challenge1,
)
challenge2.save()
challenge3 = Challenge(
course=self.course,
prerequisite=challenge2,
)
challenge3.save()
stack = Stack(course=self.course)
stack.save()
StackChallengeRelation(stack=stack, challenge=challenge1).save()
StackChallengeRelation(stack=stack, challenge=challenge2).save()
StackChallengeRelation(stack=stack, challenge=challenge3).save()
elab1 = challenge1.get_elaboration(self.users[0])
elab2 = Elaboration(challenge=challenge2, user=self.users[0])
elab2.save()
assert stack.has_enough_peer_reviews(self.users[0]) is False
Review(elaboration=elab2, reviewer=self.users[1], appraisal='S', submission_time=datetime.now()).save()
Review(elaboration=elab2, reviewer=self.users[2], appraisal='S', submission_time=datetime.now()).save()
assert stack.has_enough_peer_reviews(self.users[0]) is False
Review(elaboration=elab1, reviewer=self.users[1], appraisal='S', submission_time=datetime.now()).save()
Review(elaboration=elab1, reviewer=self.users[2], appraisal='S', submission_time=datetime.now()).save()
assert stack.has_enough_peer_reviews(self.users[0]) is True
class StackTest(TestCase):
def setUp(self):
self.create_test_users(4)
self.create_course()
self.create_stack()
self.create_challenge()
self.create_review_question()
def create_test_user(self, username):
user = AuroraUser(username=username)
user.email = '%[email protected].' % username
user.first_name = 'Firstname_%s' % username
user.last_name = 'Lastname_%s' % username
user.nickname = 'Nickname_%s' % username
user.is_staff = False
user.is_superuser = False
password = username
user.set_password(password)
user.save()
return user
def create_test_users(self, amount):
self.users = []
for i in range(amount):
self.users.append(self.create_test_user("s%s" % i))
def create_course(self):
self.course = Course(
title='test_title',
short_title='test_short_title',
description='test_description',
course_number='test_course_number',
)
self.course.save()
for user in self.users:
CourseUserRelation(course=self.course, user=user).save()
def create_stack(self):
self.stack = Stack(title="test stack",
description="test description",
course=self.course)
self.stack.save()
def create_challenge(self):
self.challenge = Challenge(
title='test_title',
subtitle='test_subtitle',
description='test_description',
course=self.course,
)
self.challenge.save()
StackChallengeRelation(stack=self.stack,
challenge=self.challenge).save()
def create_review_question(self):
self.review_question = ReviewQuestion(
challenge=self.challenge,
order=1,
text=
"Can you find any additional material not included in this submission?"
)
self.review_question.save()
def create_review(self, elaboration, reviewer):
Review(elaboration=elaboration,
submission_time=datetime.now(),
reviewer=reviewer,
appraisal='S').save()
def test_get_challenges(self):
challenge1 = self.challenge
assert challenge1 in self.stack.get_challenges()
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
assert challenge1 in self.stack.get_challenges()
assert challenge2 in self.stack.get_challenges()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert challenge1 in self.stack.get_challenges()
assert challenge2 in self.stack.get_challenges()
assert challenge3 in self.stack.get_challenges()
def test_final_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert self.stack.get_final_challenge().id is challenge3.id
def test_first_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert self.stack.get_first_challenge().id is challenge1.id
def test_is_started(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user = self.users[0]
elaboration = Elaboration(challenge=challenge1,
user=user,
elaboration_text="")
elaboration.save()
assert self.stack.is_started(user) is False
elaboration.elaboration_text = "test"
elaboration.save()
assert self.stack.is_started(user) is True
def test_is_evaluated(self):
user = self.users[0]
tutor = self.users[1]
tutor.staff = True
tutor.save()
assert self.stack.is_evaluated(user) is False
elaboration = Elaboration(challenge=self.challenge,
user=user,
elaboration_text="test elaboration",
submission_time=datetime.now())
elaboration.save()
evaluation = Evaluation(submission=elaboration,
tutor=tutor,
evaluation_text="test_evaluation")
evaluation.save()
assert self.stack.is_evaluated(user) is False
evaluation.submission_time = datetime.now()
evaluation.evaluation_points = 10
evaluation.save()
assert self.stack.is_evaluated(user) is True
def test_get_points(self):
user = self.users[0]
tutor = self.users[1]
tutor.staff = True
tutor.save()
assert self.stack.get_points_earned(user) == 0
elaboration = Elaboration(challenge=self.challenge,
user=user,
elaboration_text="test elaboration",
submission_time=datetime.now())
elaboration.save()
evaluation = Evaluation(submission=elaboration,
tutor=tutor,
evaluation_text="test_evaluation",
submission_time=datetime.now())
for points in range(10):
evaluation.evaluation_points = points
evaluation.save()
assert self.stack.get_points_earned(user) == points
def test_last_available_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert self.stack.get_last_available_challenge(user1) == challenge1
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert self.stack.get_last_available_challenge(user1) == challenge2
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user3,
appraisal=Review.SUCCESS).save()
elaboration5 = Elaboration(challenge=challenge2,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration5.save()
elaboration6 = Elaboration(challenge=challenge2,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration6.save()
elaboration7 = Elaboration(challenge=challenge2,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration7.save()
elaboration8 = Elaboration(challenge=challenge2,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration8.save()
assert self.stack.get_last_available_challenge(user1) == challenge2
Review(elaboration=elaboration6,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration7,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration8,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert self.stack.get_last_available_challenge(user1) == challenge2
Review(elaboration=elaboration5,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration5,
submission_time=datetime.now(),
reviewer=user3,
appraisal=Review.SUCCESS).save()
assert self.stack.get_last_available_challenge(user1) == challenge3
def test_is_blocked(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert not self.stack.is_blocked(user2)
review = Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user2)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user2)
assert not self.stack.is_blocked(user3)
review = Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user3)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user3)
assert not self.stack.is_blocked(user4)
review = Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user4)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user4)
assert not self.stack.is_blocked(user1)
review = Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user1)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user1)
review = Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user3,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user1)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user1)
elaboration5 = Elaboration(challenge=challenge2,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration5.save()
elaboration6 = Elaboration(challenge=challenge2,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration6.save()
elaboration7 = Elaboration(challenge=challenge2,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration7.save()
elaboration8 = Elaboration(challenge=challenge2,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration8.save()
assert not self.stack.is_blocked(user2)
review = Review(elaboration=elaboration6,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user2)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user2)
assert not self.stack.is_blocked(user3)
review = Review(elaboration=elaboration7,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user3)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user3)
assert not self.stack.is_blocked(user4)
review = Review(elaboration=elaboration8,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user4)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user4)
assert not self.stack.is_blocked(user1)
review = Review(elaboration=elaboration5,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user1)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user1)
review = Review(elaboration=elaboration5,
submission_time=datetime.now(),
reviewer=user3,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user1)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user1)
def test_has_enough_peer_reviews(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not self.stack.has_enough_peer_reviews(user1)
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.SUCCESS).save()
assert not self.stack.has_enough_peer_reviews(user1)
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user3,
appraisal=Review.SUCCESS).save()
assert not self.stack.has_enough_peer_reviews(user1)
elaboration5 = Elaboration(challenge=challenge2,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration5.save()
elaboration6 = Elaboration(challenge=challenge2,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration6.save()
elaboration7 = Elaboration(challenge=challenge2,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration7.save()
elaboration8 = Elaboration(challenge=challenge2,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration8.save()
Review(elaboration=elaboration6,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration7,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration8,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not self.stack.has_enough_peer_reviews(user1)
Review(elaboration=elaboration5,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.SUCCESS).save()
assert not self.stack.has_enough_peer_reviews(user1)
Review(elaboration=elaboration5,
submission_time=datetime.now(),
reviewer=user3,
appraisal=Review.SUCCESS).save()
assert self.stack.has_enough_peer_reviews(user1)
class AuroraUserTest(TestCase):
def setUp(self):
self.create_test_users(4)
self.create_course()
self.create_stack()
self.create_challenge()
self.create_review_question()
def create_test_user(self, username):
user = AuroraUser(username=username)
user.email = '%[email protected].' % username
user.first_name = 'Firstname_%s' % username
user.last_name = 'Lastname_%s' % username
user.nickname = 'Nickname_%s' % username
user.is_staff = False
user.is_superuser = False
password = username
user.set_password(password)
user.matriculation_number = username + '2857289'
user.save()
return user
def create_test_users(self, amount):
self.users = []
for i in range(amount):
self.users.append(self.create_test_user("s%s" % i))
def create_course(self):
self.course = Course(
title='test_title',
short_title='test_short_title',
description='test_description',
course_number='test_course_number',
)
self.course.save()
for user in self.users:
CourseUserRelation(course=self.course, user=user).save()
def create_stack(self):
self.stack = Stack(title="test stack", description="test description", course=self.course)
self.stack.save()
def create_challenge(self):
self.challenge = Challenge(
title='test_title',
subtitle='test_subtitle',
description='test_description',
course=self.course,
)
self.challenge.save()
StackChallengeRelation(stack=self.stack, challenge=self.challenge).save()
def create_review_question(self):
self.review_question = ReviewQuestion(
challenge=self.challenge,
order=1,
text="Can you find any additional material not included in this submission?"
)
self.review_question.save()
def create_review(self, elaboration, reviewer):
Review(elaboration=elaboration, submission_time=datetime.now(), reviewer=reviewer, appraisal='S').save()
@staticmethod
def ipython_test():
user = AuroraUser.objects.get(username='******')
c = Client()
shared_secret = settings.SSO_SHARED_SECRET.encode(encoding='latin1')
oid = '258'
now = int((datetime.utcnow() - datetime(1970, 1, 1)).total_seconds() / 10)
values_string = oid + user.matriculation_number + user.first_name + user.last_name + user.email + str(now)
hmac_calced = hmac_new(shared_secret, values_string.encode(encoding='latin1'), sha1).hexdigest()
values = {'oid': oid,
'mn': user.matriculation_number,
'firstName': user.first_name,
'lastName': user.last_name,
'mail': user.email,
'sKey': hmac_calced}
# response = c.get('sso_auth_callback', values, follow=True)
from django.http import QueryDict
q = QueryDict('', mutable=True)
for key in values.keys():
q[key] = values[key]
url = 'http://localhost:8000/sso_auth_callback?' + q.urlencode()
return url
def test_sso(self):
c = Client()
shared_secret = settings.SSO_SHARED_SECRET.encode(encoding='latin1')
oid = '258'
user = self.users[0]
now = int((datetime.utcnow() - datetime(1970, 1, 1)).total_seconds() / 10)
values_string = oid + user.matriculation_number + user.first_name + user.last_name + user.email + str(now)
hmac_calced = hmac_new(shared_secret, values_string.encode(encoding='latin1'), sha1).hexdigest()
values = {'oid': oid,
'mn': user.matriculation_number,
'firstName': user.first_name,
'lastName': user.last_name,
'mail': user.email,
'sKey': hmac_calced}
response = c.get('sso_auth_callback', values, follow=True)
def test_get_elaborations(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
assert len(user1.get_elaborations()) == 0
assert len(user2.get_elaborations()) == 0
assert len(user3.get_elaborations()) == 0
assert len(user4.get_elaborations()) == 0
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
assert len(user1.get_elaborations()) == 1
assert elaboration1 in user1.get_elaborations()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
assert len(user2.get_elaborations()) == 1
assert elaboration2 in user2.get_elaborations()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
assert len(user3.get_elaborations()) == 1
assert elaboration3 in user3.get_elaborations()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert len(user4.get_elaborations()) == 1
assert elaboration4 in user4.get_elaborations()
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user3,
appraisal=Review.SUCCESS).save()
elaboration5 = Elaboration(challenge=challenge2, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration5.save()
assert len(user1.get_elaborations()) == 2
assert elaboration1 in user1.get_elaborations()
assert elaboration5 in user1.get_elaborations()
elaboration6 = Elaboration(challenge=challenge2, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration6.save()
assert len(user2.get_elaborations()) == 2
assert elaboration2 in user2.get_elaborations()
assert elaboration6 in user2.get_elaborations()
elaboration7 = Elaboration(challenge=challenge2, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration7.save()
assert len(user3.get_elaborations()) == 2
assert elaboration3 in user3.get_elaborations()
assert elaboration7 in user3.get_elaborations()
elaboration8 = Elaboration(challenge=challenge2, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration8.save()
assert len(user4.get_elaborations()) == 2
assert elaboration4 in user4.get_elaborations()
assert elaboration8 in user4.get_elaborations()
def test_get_challenge_elaboration(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
assert not user1.get_challenge_elaboration(challenge1)
assert not user2.get_challenge_elaboration(challenge1)
assert not user3.get_challenge_elaboration(challenge1)
assert not user4.get_challenge_elaboration(challenge1)
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert user1.get_challenge_elaboration(challenge1) == elaboration1
assert user2.get_challenge_elaboration(challenge1) == elaboration2
assert user3.get_challenge_elaboration(challenge1) == elaboration3
assert user4.get_challenge_elaboration(challenge1) == elaboration4
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user3,
appraisal=Review.SUCCESS).save()
assert not user1.get_challenge_elaboration(challenge2)
assert not user2.get_challenge_elaboration(challenge2)
assert not user3.get_challenge_elaboration(challenge2)
assert not user4.get_challenge_elaboration(challenge2)
elaboration5 = Elaboration(challenge=challenge2, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration5.save()
elaboration6 = Elaboration(challenge=challenge2, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration6.save()
elaboration7 = Elaboration(challenge=challenge2, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration7.save()
elaboration8 = Elaboration(challenge=challenge2, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration8.save()
assert user1.get_challenge_elaboration(challenge2) == elaboration5
assert user2.get_challenge_elaboration(challenge2) == elaboration6
assert user3.get_challenge_elaboration(challenge2) == elaboration7
assert user4.get_challenge_elaboration(challenge2) == elaboration8
def test_get_stack_elaborations(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
assert len(user1.get_stack_elaborations(self.stack)) == 0
assert len(user2.get_stack_elaborations(self.stack)) == 0
assert len(user3.get_stack_elaborations(self.stack)) == 0
assert len(user4.get_stack_elaborations(self.stack)) == 0
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert len(user1.get_stack_elaborations(self.stack)) == 1
assert len(user2.get_stack_elaborations(self.stack)) == 1
assert len(user3.get_stack_elaborations(self.stack)) == 1
assert len(user4.get_stack_elaborations(self.stack)) == 1
assert elaboration1 in user1.get_stack_elaborations(self.stack)
assert elaboration2 in user2.get_stack_elaborations(self.stack)
assert elaboration3 in user3.get_stack_elaborations(self.stack)
assert elaboration4 in user4.get_stack_elaborations(self.stack)
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user3,
appraisal=Review.SUCCESS).save()
elaboration5 = Elaboration(challenge=challenge2, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration5.save()
elaboration6 = Elaboration(challenge=challenge2, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration6.save()
elaboration7 = Elaboration(challenge=challenge2, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration7.save()
elaboration8 = Elaboration(challenge=challenge2, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration8.save()
assert len(user1.get_stack_elaborations(self.stack)) == 2
assert len(user2.get_stack_elaborations(self.stack)) == 2
assert len(user3.get_stack_elaborations(self.stack)) == 2
assert len(user4.get_stack_elaborations(self.stack)) == 2
assert elaboration1 in user1.get_stack_elaborations(self.stack)
assert elaboration2 in user2.get_stack_elaborations(self.stack)
assert elaboration3 in user3.get_stack_elaborations(self.stack)
assert elaboration4 in user4.get_stack_elaborations(self.stack)
assert elaboration5 in user1.get_stack_elaborations(self.stack)
assert elaboration6 in user2.get_stack_elaborations(self.stack)
assert elaboration7 in user3.get_stack_elaborations(self.stack)
assert elaboration8 in user4.get_stack_elaborations(self.stack)
class AuroraUserTest(TestCase):
def setUp(self):
self.create_test_users(4)
self.create_course()
self.create_stack()
self.create_challenge()
self.create_review_question()
def create_test_user(self, username):
user = AuroraUser(username=username)
user.email = '%[email protected].' % username
user.first_name = 'Firstname_%s' % username
user.last_name = 'Lastname_%s' % username
user.nickname = 'Nickname_%s' % username
user.is_staff = False
user.is_superuser = False
password = username
user.set_password(password)
user.matriculation_number = username + '2857289'
user.save()
return user
def create_test_users(self, amount):
self.users = []
for i in range(amount):
self.users.append(self.create_test_user("s%s" % i))
def create_course(self):
self.course = Course(
title='test_title',
short_title='test_short_title',
description='test_description',
course_number='test_course_number',
)
self.course.save()
for user in self.users:
CourseUserRelation(course=self.course, user=user).save()
def create_stack(self):
self.stack = Stack(title="test stack",
description="test description",
course=self.course)
self.stack.save()
def create_challenge(self):
self.challenge = Challenge(
title='test_title',
subtitle='test_subtitle',
description='test_description',
course=self.course,
)
self.challenge.save()
StackChallengeRelation(stack=self.stack,
challenge=self.challenge).save()
def create_review_question(self):
self.review_question = ReviewQuestion(
challenge=self.challenge,
order=1,
text=
"Can you find any additional material not included in this submission?"
)
self.review_question.save()
def create_review(self, elaboration, reviewer):
Review(elaboration=elaboration,
submission_time=datetime.now(),
reviewer=reviewer,
appraisal='S').save()
@staticmethod
def ipython_test():
user = AuroraUser.objects.get(username='******')
c = Client()
shared_secret = settings.SSO_SHARED_SECRET.encode(encoding='latin1')
oid = '258'
now = int(
(datetime.utcnow() - datetime(1970, 1, 1)).total_seconds() / 10)
values_string = oid + user.matriculation_number + user.first_name + user.last_name + user.email + str(
now)
hmac_calced = hmac_new(shared_secret,
values_string.encode(encoding='latin1'),
sha1).hexdigest()
values = {
'oid': oid,
'mn': user.matriculation_number,
'firstName': user.first_name,
'lastName': user.last_name,
'mail': user.email,
'sKey': hmac_calced
}
# response = c.get('sso_auth_callback', values, follow=True)
from django.http import QueryDict
q = QueryDict('', mutable=True)
for key in values.keys():
q[key] = values[key]
url = 'http://localhost:8000/sso_auth_callback?' + q.urlencode()
return url
def test_sso(self):
c = Client()
shared_secret = settings.SSO_SHARED_SECRET.encode(encoding='latin1')
oid = '258'
user = self.users[0]
now = int(
(datetime.utcnow() - datetime(1970, 1, 1)).total_seconds() / 10)
values_string = oid + user.matriculation_number + user.first_name + user.last_name + user.email + str(
now)
hmac_calced = hmac_new(shared_secret,
values_string.encode(encoding='latin1'),
sha1).hexdigest()
values = {
'oid': oid,
'mn': user.matriculation_number,
'firstName': user.first_name,
'lastName': user.last_name,
'mail': user.email,
'sKey': hmac_calced
}
response = c.get('sso_auth_callback', values, follow=True)
def test_get_elaborations(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
assert len(user1.get_elaborations()) == 0
assert len(user2.get_elaborations()) == 0
assert len(user3.get_elaborations()) == 0
assert len(user4.get_elaborations()) == 0
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
assert len(user1.get_elaborations()) == 1
assert elaboration1 in user1.get_elaborations()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
assert len(user2.get_elaborations()) == 1
assert elaboration2 in user2.get_elaborations()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
assert len(user3.get_elaborations()) == 1
assert elaboration3 in user3.get_elaborations()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert len(user4.get_elaborations()) == 1
assert elaboration4 in user4.get_elaborations()
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user3,
appraisal=Review.SUCCESS).save()
elaboration5 = Elaboration(challenge=challenge2,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration5.save()
assert len(user1.get_elaborations()) == 2
assert elaboration1 in user1.get_elaborations()
assert elaboration5 in user1.get_elaborations()
elaboration6 = Elaboration(challenge=challenge2,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration6.save()
assert len(user2.get_elaborations()) == 2
assert elaboration2 in user2.get_elaborations()
assert elaboration6 in user2.get_elaborations()
elaboration7 = Elaboration(challenge=challenge2,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration7.save()
assert len(user3.get_elaborations()) == 2
assert elaboration3 in user3.get_elaborations()
assert elaboration7 in user3.get_elaborations()
elaboration8 = Elaboration(challenge=challenge2,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration8.save()
assert len(user4.get_elaborations()) == 2
assert elaboration4 in user4.get_elaborations()
assert elaboration8 in user4.get_elaborations()
def test_get_challenge_elaboration(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
assert not user1.get_challenge_elaboration(challenge1)
assert not user2.get_challenge_elaboration(challenge1)
assert not user3.get_challenge_elaboration(challenge1)
assert not user4.get_challenge_elaboration(challenge1)
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert user1.get_challenge_elaboration(challenge1) == elaboration1
assert user2.get_challenge_elaboration(challenge1) == elaboration2
assert user3.get_challenge_elaboration(challenge1) == elaboration3
assert user4.get_challenge_elaboration(challenge1) == elaboration4
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user3,
appraisal=Review.SUCCESS).save()
assert not user1.get_challenge_elaboration(challenge2)
assert not user2.get_challenge_elaboration(challenge2)
assert not user3.get_challenge_elaboration(challenge2)
assert not user4.get_challenge_elaboration(challenge2)
elaboration5 = Elaboration(challenge=challenge2,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration5.save()
elaboration6 = Elaboration(challenge=challenge2,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration6.save()
elaboration7 = Elaboration(challenge=challenge2,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration7.save()
elaboration8 = Elaboration(challenge=challenge2,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration8.save()
assert user1.get_challenge_elaboration(challenge2) == elaboration5
assert user2.get_challenge_elaboration(challenge2) == elaboration6
assert user3.get_challenge_elaboration(challenge2) == elaboration7
assert user4.get_challenge_elaboration(challenge2) == elaboration8
def test_get_stack_elaborations(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
assert len(user1.get_stack_elaborations(self.stack)) == 0
assert len(user2.get_stack_elaborations(self.stack)) == 0
assert len(user3.get_stack_elaborations(self.stack)) == 0
assert len(user4.get_stack_elaborations(self.stack)) == 0
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert len(user1.get_stack_elaborations(self.stack)) == 1
assert len(user2.get_stack_elaborations(self.stack)) == 1
assert len(user3.get_stack_elaborations(self.stack)) == 1
assert len(user4.get_stack_elaborations(self.stack)) == 1
assert elaboration1 in user1.get_stack_elaborations(self.stack)
assert elaboration2 in user2.get_stack_elaborations(self.stack)
assert elaboration3 in user3.get_stack_elaborations(self.stack)
assert elaboration4 in user4.get_stack_elaborations(self.stack)
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user3,
appraisal=Review.SUCCESS).save()
elaboration5 = Elaboration(challenge=challenge2,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration5.save()
elaboration6 = Elaboration(challenge=challenge2,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration6.save()
elaboration7 = Elaboration(challenge=challenge2,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration7.save()
elaboration8 = Elaboration(challenge=challenge2,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration8.save()
assert len(user1.get_stack_elaborations(self.stack)) == 2
assert len(user2.get_stack_elaborations(self.stack)) == 2
assert len(user3.get_stack_elaborations(self.stack)) == 2
assert len(user4.get_stack_elaborations(self.stack)) == 2
assert elaboration1 in user1.get_stack_elaborations(self.stack)
assert elaboration2 in user2.get_stack_elaborations(self.stack)
assert elaboration3 in user3.get_stack_elaborations(self.stack)
assert elaboration4 in user4.get_stack_elaborations(self.stack)
assert elaboration5 in user1.get_stack_elaborations(self.stack)
assert elaboration6 in user2.get_stack_elaborations(self.stack)
assert elaboration7 in user3.get_stack_elaborations(self.stack)
assert elaboration8 in user4.get_stack_elaborations(self.stack)
class ChallengeTest(TestCase):
def setUp(self):
self.create_test_users(4)
self.create_course()
self.create_stack()
self.create_challenge()
self.create_review_question()
def create_test_user(self, username):
user = AuroraUser(username=username)
user.email = '%[email protected].' % username
user.first_name = 'Firstname_%s' % username
user.last_name = 'Lastname_%s' % username
user.nickname = 'Nickname_%s' % username
user.is_staff = False
user.is_superuser = False
password = username
user.set_password(password)
user.save()
return user
def create_test_users(self, amount):
self.users = []
for i in range(amount):
self.users.append(self.create_test_user("s%s" % i))
def create_course(self):
self.course = Course(
title='test_title',
short_title='test_short_title',
description='test_description',
course_number='test_course_number',
)
self.course.save()
for user in self.users:
CourseUserRelation(course=self.course, user=user).save()
def create_stack(self):
self.stack = Stack(title="test stack",
description="test description",
course=self.course)
self.stack.save()
def create_challenge(self):
self.challenge = Challenge(
title='test_title',
subtitle='test_subtitle',
description='test_description',
course=self.course,
)
self.challenge.save()
StackChallengeRelation(stack=self.stack,
challenge=self.challenge).save()
def create_review_question(self):
self.review_question = ReviewQuestion(
challenge=self.challenge,
order=1,
text=
"Can you find any additional material not included in this submission?"
)
self.review_question.save()
def create_review(self, elaboration, reviewer):
Review(elaboration=elaboration,
submission_time=datetime.now(),
reviewer=reviewer,
appraisal='S').save()
def test_next(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert challenge1.get_next() == challenge2
assert challenge2.get_next() == challenge3
assert challenge3.get_next() is None
def test_get_elaboration(self):
user = self.users[0]
assert self.challenge.get_elaboration(user) is None
elaboration = Elaboration(challenge=self.challenge,
user=user,
elaboration_text="test")
elaboration.save()
assert self.challenge.get_elaboration(user) == elaboration
def test_get_stack(self):
challenge = Challenge(title='test_title',
subtitle='test_subtitle',
description='test_description',
course=self.course)
challenge.save()
assert challenge.get_stack() is None
assert self.challenge.get_stack() == self.stack
def test_is_first_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert challenge1.is_first_challenge()
assert not challenge2.is_first_challenge()
assert not challenge3.is_first_challenge()
def test_is_final_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert not challenge1.is_final_challenge()
assert not challenge2.is_final_challenge()
assert challenge3.is_final_challenge()
def test_get_final_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert challenge1.get_final_challenge() == challenge3
assert challenge2.get_final_challenge() == challenge3
assert challenge3.get_final_challenge() == challenge3
def test_get_first_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert challenge1.get_first_challenge() == challenge1
assert challenge2.get_first_challenge() == challenge1
assert challenge3.get_first_challenge() == challenge1
def test_has_enough_user_reviews(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
user1 = self.users[0]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
user2 = self.users[1]
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
user3 = self.users[2]
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
user4 = self.users[3]
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert not challenge1.has_enough_user_reviews(user1)
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not challenge1.has_enough_user_reviews(user1)
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not challenge1.has_enough_user_reviews(user1)
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.has_enough_user_reviews(user1)
def test_is_started(self):
user = self.users[0]
elaboration = Elaboration(challenge=self.challenge,
user=user,
elaboration_text="")
elaboration.save()
assert self.challenge.is_started(user) is False
elaboration.elaboration_text = "test"
elaboration.save()
assert self.challenge.is_started(user) is True
def test_submitted_by_user(self):
user = self.users[0]
elaboration = Elaboration(challenge=self.challenge,
user=user,
elaboration_text="test")
elaboration.save()
assert not self.challenge.submitted_by_user(user)
elaboration.submission_time = datetime.now()
elaboration.save()
assert self.challenge.submitted_by_user(user)
def test_get_review_written_by_user(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
user1 = self.users[0]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
user2 = self.users[1]
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
user3 = self.users[2]
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
user4 = self.users[3]
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert len(challenge1.get_reviews_written_by_user(user1)) == 0
review1 = Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS)
review1.save()
assert len(challenge1.get_reviews_written_by_user(user1)) == 1
assert review1 in challenge1.get_reviews_written_by_user(user1)
review2 = Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS)
review2.save()
assert len(challenge1.get_reviews_written_by_user(user1)) == 2
assert review1 in challenge1.get_reviews_written_by_user(user1)
assert review2 in challenge1.get_reviews_written_by_user(user1)
review3 = Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS)
review3.save()
assert len(challenge1.get_reviews_written_by_user(user1)) == 3
assert review1 in challenge1.get_reviews_written_by_user(user1)
assert review2 in challenge1.get_reviews_written_by_user(user1)
assert review3 in challenge1.get_reviews_written_by_user(user1)
def test_get_elaborations(self):
assert len(self.challenge.get_elaborations()) == 0
user = self.users[0]
elaboration = Elaboration(challenge=self.challenge,
user=user,
elaboration_text="test")
elaboration.save()
assert len(self.challenge.get_elaborations()) == 1
assert elaboration in self.challenge.get_elaborations()
def test_first_challenge_is_always_enabled(self):
user = self.users[0]
assert self.challenge.is_enabled_for_user(user)
def test_already_submitted_challenges_are_enabled(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
user = self.users[0]
assert not challenge2.is_enabled_for_user(user)
elaboration = Elaboration(challenge=challenge2,
user=user,
elaboration_text="test")
elaboration.save()
assert not challenge2.is_enabled_for_user(user)
elaboration.submission_time = datetime.now()
elaboration.save()
assert challenge2.is_enabled_for_user(user)
def test_enough_user_reviews_required(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert not challenge2.is_enabled_for_user(user1)
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not challenge2.is_enabled_for_user(user1)
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not challenge2.is_enabled_for_user(user1)
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge2.is_enabled_for_user(user1)
def test_if_stack_blocked_challenge_is_not_enabled_fail(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge2.is_enabled_for_user(user1)
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.FAIL).save()
# a failed review does not block the stack
assert challenge2.is_enabled_for_user(user1)
def test_if_stack_blocked_challenge_is_not_enabled_nothing(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge2.is_enabled_for_user(user1)
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.NOTHING).save()
# nothing should not block a user from working
assert challenge2.is_enabled_for_user(user1)
def test_final_challenge_enabled(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not challenge2.is_enabled_for_user(user1)
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user3,
appraisal=Review.SUCCESS).save()
assert challenge2.is_enabled_for_user(user1)
def test_final_challenge_enabled_bug_issue_114(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not challenge3.is_enabled_for_user(user1)
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user3,
appraisal=Review.SUCCESS).save()
assert not challenge3.is_enabled_for_user(user1)
def test_status_not_started(self):
user = self.users[0]
assert self.challenge.is_enabled_for_user(user)
assert self.challenge.get_status(user) == Challenge.NOT_STARTED
def test_status_not_submitted(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
user = self.users[0]
assert challenge1.get_status(user) == Challenge.NOT_STARTED
elaboration = Elaboration(challenge=challenge1,
user=user,
elaboration_text="test")
elaboration.save()
assert challenge1.is_enabled_for_user(user)
assert challenge1.get_status(user) == Challenge.NOT_SUBMITTED
assert not challenge2.is_enabled_for_user(user)
assert challenge2.get_status(user) == Challenge.NOT_ENABLED
def test_status_blocked_bad_review_fail(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert not challenge2.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.USER_REVIEW_MISSING
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
bad_review = Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.FAIL)
bad_review.save()
assert not challenge2.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.USER_REVIEW_MISSING
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
bad_review.appraisal = Review.SUCCESS
bad_review.save()
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.has_enough_user_reviews(user1)
assert challenge1.get_status(
user1) == Challenge.DONE_MISSING_PEER_REVIEW
assert challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_STARTED
bad_review.appraisal = Review.FAIL
bad_review.save()
assert challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_STARTED
def test_status_blocked_bad_review_nothing(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert not challenge2.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.USER_REVIEW_MISSING
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
bad_review = Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.NOTHING)
bad_review.save()
assert not challenge2.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.BLOCKED_BAD_REVIEW
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
bad_review.appraisal = Review.SUCCESS
bad_review.save()
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.has_enough_user_reviews(user1)
assert challenge1.get_status(
user1) == Challenge.DONE_MISSING_PEER_REVIEW
assert challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_STARTED
bad_review.appraisal = Review.NOTHING
bad_review.save()
assert challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_STARTED
def test_status_user_review_missing(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert challenge1.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.USER_REVIEW_MISSING
assert not challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.USER_REVIEW_MISSING
assert not challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.is_enabled_for_user(user1)
assert challenge1.get_status(user1) == Challenge.USER_REVIEW_MISSING
assert not challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.is_enabled_for_user(user1)
assert challenge1.get_status(
user1) == Challenge.DONE_MISSING_PEER_REVIEW
assert challenge2.is_enabled_for_user(user1)
assert challenge2.get_status(user1) == Challenge.NOT_STARTED
def test_status_done_missing_peer_review(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.get_status(
user1) == Challenge.DONE_MISSING_PEER_REVIEW
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.SUCCESS).save()
assert challenge1.get_status(
user1) == Challenge.DONE_MISSING_PEER_REVIEW
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user3,
appraisal=Review.SUCCESS).save()
assert challenge1.get_status(
user1) == Challenge.DONE_MISSING_PEER_REVIEW
def test_status_final_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
user1 = self.users[0]
elaboration1 = Elaboration(challenge=challenge1,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
user2 = self.users[1]
elaboration2 = Elaboration(challenge=challenge1,
user=user2,
elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
user3 = self.users[2]
elaboration3 = Elaboration(challenge=challenge1,
user=user3,
elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
user4 = self.users[3]
elaboration4 = Elaboration(challenge=challenge1,
user=user4,
elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4,
submission_time=datetime.now(),
reviewer=user1,
appraisal=Review.SUCCESS).save()
assert challenge1.get_status(
user1) == Challenge.DONE_MISSING_PEER_REVIEW
assert challenge2.get_status(user1) == Challenge.NOT_ENABLED
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1,
submission_time=datetime.now(),
reviewer=user3,
appraisal=Review.SUCCESS).save()
assert challenge1.get_status(user1) == Challenge.DONE_PEER_REVIEWED
assert challenge2.get_status(user1) == Challenge.NOT_STARTED
final_elaboration = Elaboration(challenge=challenge2,
user=user1,
elaboration_text="test",
submission_time=datetime.now())
final_elaboration.save()
assert challenge2.get_status(user1) == Challenge.WAITING_FOR_EVALUATION
tutor = user4
tutor.staff = True
tutor.save()
Evaluation(submission=final_elaboration,
tutor=tutor,
evaluation_text="test evaluation",
evaluation_points=10,
submission_time=datetime.now()).save()
assert challenge2.get_status(user1) == Challenge.EVALUATED
class SimpleTest(TestCase):
def setUp(self):
self.create_test_users(4)
self.create_course()
self.create_challenge()
self.create_review_question()
self.create_elaborations()
def create_test_user(self, username):
user = AuroraUser(username=username)
user.email = '%[email protected].' % username
user.first_name = 'Firstname_%s' % username
user.last_name = 'Lastname_%s' % username
user.nickname = 'Nickname_%s' % username
user.is_staff = False
user.is_superuser = False
password = username
user.set_password(password)
user.save()
return user
def create_test_users(self, amount):
self.users = []
for i in range(amount):
self.users.append(self.create_test_user("s%s" % i))
def create_course(self):
self.course = Course(
title='test_title',
short_title='test_short_title',
description='test_description',
course_number='test_course_number',
)
self.course.save()
for user in self.users:
CourseUserRelation(course=self.course, user=user).save()
def create_challenge(self):
self.challenge = Challenge(
title='test_title',
subtitle='test_subtitle',
description='test_description',
course=self.course,
)
self.challenge.save()
def create_review_question(self):
self.review_question = ReviewQuestion(
challenge=self.challenge,
order=1,
text=
"Can you find any additional material not included in this submission?"
)
self.review_question.save()
def create_elaborations(self):
self.elaborations = []
for user in self.users:
elaboration = Elaboration(challenge=self.challenge,
user=user,
elaboration_text="test_text",
submission_time=datetime.now())
elaboration.save()
self.elaborations.append(elaboration)
def create_review_without_submission_date(self, elaboration, reviewer):
Review(elaboration=elaboration, reviewer=reviewer,
appraisal='S').save()
def create_review(self, elaboration, reviewer):
Review(elaboration=elaboration,
reviewer=reviewer,
submission_time=datetime.now(),
appraisal='S').save()
def test_get_open_review(self):
user1 = self.users[0]
user2 = self.users[2]
elaboration = self.elaborations[0]
self.create_review_without_submission_date(elaboration=elaboration,
reviewer=user1)
# there should be an open review for user1
review = Review.get_open_review(self.challenge, user1)
assert review
assert review.reviewer == user1
assert review.elaboration == elaboration
# there should be no open review for user1 since the review is already submitted
review.submission_time = datetime.now()
review.save()
review = Review.get_open_review(self.challenge, user1)
assert not review
# there should be no open review for user2
review = Review.get_open_review(self.challenge, user2)
assert not review
# user1 and user2 both have separate open reviews
self.create_review_without_submission_date(elaboration=elaboration,
reviewer=user1)
self.create_review_without_submission_date(elaboration=elaboration,
reviewer=user2)
review1 = Review.get_open_review(self.challenge, user1)
review2 = Review.get_open_review(self.challenge, user2)
assert review1
assert review2
assert review1.id != review2.id
assert review1.reviewer == user1
assert review2.reviewer == user2
assert review1.elaboration == elaboration and review2.elaboration == elaboration
def test_review_config_offset(self):
assert ReviewConfig.get_candidate_offset_min() == 0
assert ReviewConfig.get_candidate_offset_max() == 0
ReviewConfig(candidate_offset_min=1, candidate_offset_max=2).save()
assert ReviewConfig.get_candidate_offset_min() == 1
assert ReviewConfig.get_candidate_offset_max() == 2
def test_notification_too_soon(self):
challenge1 = self.challenge
challenge2 = Challenge(
course=self.course,
prerequisite=challenge1,
)
challenge2.save()
challenge3 = Challenge(
course=self.course,
prerequisite=challenge2,
)
challenge3.save()
stack = Stack(course=self.course)
stack.save()
StackChallengeRelation(stack=stack, challenge=challenge1).save()
StackChallengeRelation(stack=stack, challenge=challenge2).save()
StackChallengeRelation(stack=stack, challenge=challenge3).save()
elab1 = challenge1.get_elaboration(self.users[0])
elab2 = Elaboration(challenge=challenge2, user=self.users[0])
elab2.save()
assert stack.has_enough_peer_reviews(self.users[0]) is False
Review(elaboration=elab2,
reviewer=self.users[1],
appraisal='S',
submission_time=datetime.now()).save()
Review(elaboration=elab2,
reviewer=self.users[2],
appraisal='S',
submission_time=datetime.now()).save()
assert stack.has_enough_peer_reviews(self.users[0]) is False
Review(elaboration=elab1,
reviewer=self.users[1],
appraisal='S',
submission_time=datetime.now()).save()
Review(elaboration=elab1,
reviewer=self.users[2],
appraisal='S',
submission_time=datetime.now()).save()
assert stack.has_enough_peer_reviews(self.users[0]) is True
class StackTest(TestCase):
def setUp(self):
self.create_test_users(4)
self.create_course()
self.create_stack()
self.create_challenge()
self.create_review_question()
def create_test_user(self, username):
user = AuroraUser(username=username)
user.email = '%[email protected].' % username
user.first_name = 'Firstname_%s' % username
user.last_name = 'Lastname_%s' % username
user.nickname = 'Nickname_%s' % username
user.is_staff = False
user.is_superuser = False
password = username
user.set_password(password)
user.save()
return user
def create_test_users(self, amount):
self.users = []
for i in range(amount):
self.users.append(self.create_test_user("s%s" % i))
def create_course(self):
self.course = Course(
title='test_title',
short_title='test_short_title',
description='test_description',
course_number='test_course_number',
)
self.course.save()
for user in self.users:
CourseUserRelation(course=self.course, user=user).save()
def create_stack(self):
self.stack = Stack(title="test stack", description="test description", course=self.course)
self.stack.save()
def create_challenge(self):
self.challenge = Challenge(
title='test_title',
subtitle='test_subtitle',
description='test_description',
course=self.course,
)
self.challenge.save()
StackChallengeRelation(stack=self.stack, challenge=self.challenge).save()
def create_review_question(self):
self.review_question = ReviewQuestion(
challenge=self.challenge,
order=1,
text="Can you find any additional material not included in this submission?"
)
self.review_question.save()
def create_review(self, elaboration, reviewer):
Review(elaboration=elaboration, submission_time=datetime.now(), reviewer=reviewer, appraisal='S').save()
def test_get_challenges(self):
challenge1 = self.challenge
assert challenge1 in self.stack.get_challenges()
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
assert challenge1 in self.stack.get_challenges()
assert challenge2 in self.stack.get_challenges()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert challenge1 in self.stack.get_challenges()
assert challenge2 in self.stack.get_challenges()
assert challenge3 in self.stack.get_challenges()
def test_final_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert self.stack.get_final_challenge().id is challenge3.id
def test_first_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
assert self.stack.get_first_challenge().id is challenge1.id
def test_is_started(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user = self.users[0]
elaboration = Elaboration(challenge=challenge1, user=user, elaboration_text="")
elaboration.save()
assert self.stack.is_started(user) is False
elaboration.elaboration_text = "test"
elaboration.save()
assert self.stack.is_started(user) is True
def test_is_evaluated(self):
user = self.users[0]
tutor = self.users[1]
tutor.staff = True
tutor.save()
assert self.stack.is_evaluated(user) is False
elaboration = Elaboration(challenge=self.challenge, user=user, elaboration_text="test elaboration",
submission_time=datetime.now())
elaboration.save()
evaluation = Evaluation(submission=elaboration, tutor=tutor, evaluation_text="test_evaluation")
evaluation.save()
assert self.stack.is_evaluated(user) is False
evaluation.submission_time = datetime.now()
evaluation.evaluation_points = 10
evaluation.save()
assert self.stack.is_evaluated(user) is True
def test_get_points(self):
user = self.users[0]
tutor = self.users[1]
tutor.staff = True
tutor.save()
assert self.stack.get_points_earned(user) == 0
elaboration = Elaboration(challenge=self.challenge, user=user, elaboration_text="test elaboration",
submission_time=datetime.now())
elaboration.save()
evaluation = Evaluation(submission=elaboration, tutor=tutor, evaluation_text="test_evaluation",
submission_time=datetime.now())
for points in range(10):
evaluation.evaluation_points = points
evaluation.save()
assert self.stack.get_points_earned(user) == points
def test_last_available_challenge(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert self.stack.get_last_available_challenge(user1) == challenge1
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert self.stack.get_last_available_challenge(user1) == challenge2
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user3,
appraisal=Review.SUCCESS).save()
elaboration5 = Elaboration(challenge=challenge2, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration5.save()
elaboration6 = Elaboration(challenge=challenge2, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration6.save()
elaboration7 = Elaboration(challenge=challenge2, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration7.save()
elaboration8 = Elaboration(challenge=challenge2, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration8.save()
assert self.stack.get_last_available_challenge(user1) == challenge2
Review(elaboration=elaboration6, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration7, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration8, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert self.stack.get_last_available_challenge(user1) == challenge2
Review(elaboration=elaboration5, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration5, submission_time=datetime.now(), reviewer=user3,
appraisal=Review.SUCCESS).save()
assert self.stack.get_last_available_challenge(user1) == challenge3
def test_is_blocked(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
assert not self.stack.is_blocked(user2)
review = Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user2)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user2)
assert not self.stack.is_blocked(user3)
review = Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user3)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user3)
assert not self.stack.is_blocked(user4)
review = Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user4)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user4)
assert not self.stack.is_blocked(user1)
review = Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user1)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user1)
review = Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user3,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user1)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user1)
elaboration5 = Elaboration(challenge=challenge2, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration5.save()
elaboration6 = Elaboration(challenge=challenge2, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration6.save()
elaboration7 = Elaboration(challenge=challenge2, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration7.save()
elaboration8 = Elaboration(challenge=challenge2, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration8.save()
assert not self.stack.is_blocked(user2)
review = Review(elaboration=elaboration6, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user2)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user2)
assert not self.stack.is_blocked(user3)
review = Review(elaboration=elaboration7, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user3)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user3)
assert not self.stack.is_blocked(user4)
review = Review(elaboration=elaboration8, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user4)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user4)
assert not self.stack.is_blocked(user1)
review = Review(elaboration=elaboration5, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user1)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user1)
review = Review(elaboration=elaboration5, submission_time=datetime.now(), reviewer=user3,
appraisal=Review.NOTHING)
review.save()
assert self.stack.is_blocked(user1)
review.appraisal = Review.SUCCESS
review.save()
assert not self.stack.is_blocked(user1)
def test_has_enough_peer_reviews(self):
challenge1 = self.challenge
self.create_challenge()
challenge2 = self.challenge
challenge2.prerequisite = challenge1
challenge2.save()
self.create_challenge()
challenge3 = self.challenge
challenge3.prerequisite = challenge2
challenge3.save()
user1 = self.users[0]
user2 = self.users[1]
user3 = self.users[2]
user4 = self.users[3]
elaboration1 = Elaboration(challenge=challenge1, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration1.save()
elaboration2 = Elaboration(challenge=challenge1, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration2.save()
elaboration3 = Elaboration(challenge=challenge1, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration3.save()
elaboration4 = Elaboration(challenge=challenge1, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration4.save()
Review(elaboration=elaboration2, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration3, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration4, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not self.stack.has_enough_peer_reviews(user1)
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.SUCCESS).save()
assert not self.stack.has_enough_peer_reviews(user1)
Review(elaboration=elaboration1, submission_time=datetime.now(), reviewer=user3,
appraisal=Review.SUCCESS).save()
assert not self.stack.has_enough_peer_reviews(user1)
elaboration5 = Elaboration(challenge=challenge2, user=user1, elaboration_text="test",
submission_time=datetime.now())
elaboration5.save()
elaboration6 = Elaboration(challenge=challenge2, user=user2, elaboration_text="test",
submission_time=datetime.now())
elaboration6.save()
elaboration7 = Elaboration(challenge=challenge2, user=user3, elaboration_text="test",
submission_time=datetime.now())
elaboration7.save()
elaboration8 = Elaboration(challenge=challenge2, user=user4, elaboration_text="test",
submission_time=datetime.now())
elaboration8.save()
Review(elaboration=elaboration6, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration7, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
Review(elaboration=elaboration8, submission_time=datetime.now(), reviewer=user1,
appraisal=Review.SUCCESS).save()
assert not self.stack.has_enough_peer_reviews(user1)
Review(elaboration=elaboration5, submission_time=datetime.now(), reviewer=user2,
appraisal=Review.SUCCESS).save()
assert not self.stack.has_enough_peer_reviews(user1)
Review(elaboration=elaboration5, submission_time=datetime.now(), reviewer=user3,
appraisal=Review.SUCCESS).save()
assert self.stack.has_enough_peer_reviews(user1)
