def test_fit_for_study(self): random_bookmarks = [BookmarkRule(self.user).bookmark for _ in range(0, 2)] random_exercise = ExerciseRule().exercise random_exercise.outcome = OutcomeRule().wrong random_bookmarks[0].starred = True random_bookmarks[1].starred = True random_bookmarks[1].add_new_exercise(random_exercise) for b in random_bookmarks: assert b.fit_for_study
def test_is_learned_based_on_exercise_outcomes(self): random_bookmarks = [BookmarkRule(self.user).bookmark for _ in range(0, 4)] # Empty exercise_log should lead to a False return learned = is_learned_based_on_exercise_outcomes( SortedExerciseLog(random_bookmarks[0]) ) assert not learned # An exercise with Outcome equal to TOO EASY results in True, and time of last exercise random_exercise = ExerciseRule().exercise random_exercise.outcome = OutcomeRule().too_easy random_bookmarks[1].add_new_exercise(random_exercise) learned = is_learned_based_on_exercise_outcomes( SortedExerciseLog(random_bookmarks[1]) ) result_time = SortedExerciseLog(random_bookmarks[1]).last_exercise_time() assert learned and result_time == random_exercise.time # Same test as above, but without a second return value learned = is_learned_based_on_exercise_outcomes( SortedExerciseLog(random_bookmarks[1]) ) assert learned # A bookmark with CORRECTS_IN_A_ROW_FOR_LEARNED correct exercises in a row # returns true and the time of the last exercise correct_bookmark = random_bookmarks[2] exercises = 0 distinct_dates = set() while not ( exercises >= CORRECTS_IN_A_ROW_FOR_LEARNED and len(distinct_dates) >= CORRECTS_IN_DISTINCT_DAYS_FOR_LEARNED ): correct_exercise = ExerciseRule().exercise correct_exercise.outcome = OutcomeRule().correct correct_bookmark.add_new_exercise(correct_exercise) exercises += 1 distinct_dates.add(correct_exercise.time.date()) correct_bookmark.update_learned_status(self.db.session) log = SortedExerciseLog(correct_bookmark) learned = is_learned_based_on_exercise_outcomes(log) result_time = log.last_exercise_time() assert learned log = SortedExerciseLog(correct_bookmark) learned_time_from_log = log.last_exercise_time() assert result_time == learned_time_from_log # A bookmark with no TOO EASY outcome or less than 5 correct exercises in a row returns False, None wrong_exercise = ExerciseRule().exercise wrong_exercise.outcome = OutcomeRule().wrong random_bookmarks[3].add_new_exercise(wrong_exercise) log = SortedExerciseLog(random_bookmarks[3]) learned = is_learned_based_on_exercise_outcomes(log) assert not learned
def test_has_been_learned(self): random_bookmarks = [ BookmarkRule(self.user).bookmark for _ in range(0, 2) ] random_exercise = ExerciseRule().exercise random_exercise.outcome = OutcomeRule().too_easy random_bookmarks[0].add_new_exercise(random_exercise) result_bool, result_time = random_bookmarks[0].has_been_learned( also_return_time=True) assert result_bool and result_time == random_bookmarks[0].exercise_log[ -1].time result_bool, result_None = random_bookmarks[1].has_been_learned( also_return_time=True) assert not result_bool and result_None is None
def test_add_new_exercise(self): random_bookmark = BookmarkRule(self.user).bookmark length_original_exercise_log = len(random_bookmark.exercise_log) random_exercise = ExerciseRule().exercise random_bookmark.add_new_exercise(random_exercise) length_new_exercise_log = len(random_bookmark.exercise_log) assert length_original_exercise_log < length_new_exercise_log
def test_latest_exercise_outcome(self): random_bookmark = self.user.all_bookmarks()[0] assert random_bookmark.latest_exercise_outcome() is None random_exercise = ExerciseRule().exercise random_bookmark.add_new_exercise(random_exercise) assert random_exercise.outcome == random_bookmark.latest_exercise_outcome( )
def test_latest_exercise_outcome(self): random_bookmark = self.user.all_bookmarks()[0] exercise_log = SortedExerciseLog(random_bookmark) assert exercise_log.latest_exercise_outcome() is None random_exercise = ExerciseRule().exercise random_bookmark.add_new_exercise(random_exercise) assert random_exercise.outcome == SortedExerciseLog(random_bookmark).latest_exercise_outcome()
def test_check_if_learned_based_on_exercise_outcomes(self): random_bookmarks = [ BookmarkRule(self.user).bookmark for _ in range(0, 4) ] # Empty exercise_log should lead to a False return assert not random_bookmarks[ 0].check_if_learned_based_on_exercise_outcomes() # An exercise with Outcome equal to TOO EASY results in True, and time of last exercise random_exercise = ExerciseRule().exercise random_exercise.outcome = OutcomeRule().too_easy random_bookmarks[1].add_new_exercise(random_exercise) result_bool, result_time = random_bookmarks[ 1].check_if_learned_based_on_exercise_outcomes( add_to_result_time=True) assert result_bool and result_time == random_exercise.time # Same test as above, but without a second return value assert random_bookmarks[1].check_if_learned_based_on_exercise_outcomes( ) # A bookmark with 5 correct exercises in a row returns true and the time of the last exercise for i in range(0, 5): correct_exercise = ExerciseRule().exercise correct_exercise.outcome = OutcomeRule().correct random_bookmarks[2].add_new_exercise(correct_exercise) result_bool, result_time = random_bookmarks[ 2].check_if_learned_based_on_exercise_outcomes() assert result_bool and result_time == random_bookmarks[2].exercise_log[ -1].time random_bookmarks[2].update_learned_status(self.db.session) # A bookmark with no TOO EASY outcome or less than 5 correct exercises in a row returns False, None wrong_exercise = ExerciseRule().exercise wrong_exercise.outcome = OutcomeRule().wrong random_bookmarks[3].add_new_exercise(wrong_exercise) result_bool, result_None = random_bookmarks[ 3].check_if_learned_based_on_exercise_outcomes( add_to_result_time=True) assert not result_bool and result_None is None # Same as before, but without a second return value assert not random_bookmarks[ 3].check_if_learned_based_on_exercise_outcomes()
def test_add_exercise_outcome(self): random_bookmark = BookmarkRule(self.user).bookmark random_exercise = ExerciseRule().exercise random_bookmark.add_new_exercise_result(random_exercise.source, random_exercise.outcome, random_exercise.solving_speed) latest_exercise = random_bookmark.exercise_log[-1] assert latest_exercise.source == random_exercise.source assert latest_exercise.outcome == random_exercise.outcome assert latest_exercise.solving_speed == random_exercise.solving_speed
def add_bookmarks(self, bookmark_count, exercises_count=0, **kwargs): bookmark_rules = [] for _ in range(bookmark_count): bookmark_rule = BookmarkRule(self.user, **kwargs) bookmark = bookmark_rule.bookmark for i in range(0, exercises_count): random_exercise = ExerciseRule().exercise bookmark.add_new_exercise(random_exercise) bookmark_rules.append(bookmark_rule) return bookmark_rules
def test_just_finished_bookmark_has_not_the_highest_priority(self): # GIVEN ABTesting._algorithms = [ABTesting._algorithms[random.randint(0, len(ABTesting._algorithms) - 1)]] arts.update_bookmark_priority(zeeguu_core.db, self.user) first_bookmark_to_study = self.__get_bookmark_with_highest_priority() # WHEN # Add an exercise exercise_rule = ExerciseRule() exercise_rule.exercise.time = datetime.now() exercise_rule.exercise.solving_speed = 100 exercise_rule.exercise.outcome = OutcomeRule().correct first_bookmark_to_study.add_new_exercise(exercise_rule.exercise) arts.update_bookmark_priority(zeeguu_core.db, self.user) # THEN bookmark = self.__get_bookmark_with_highest_priority() assert first_bookmark_to_study != bookmark