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_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_new_exercise_result(self): random_bookmark = BookmarkRule(self.user).bookmark exercise_count_before = len(random_bookmark.exercise_log) random_bookmark.add_new_exercise_result(SourceRule().random, OutcomeRule().random, random.randint(100, 1000)) exercise_count_after = len(random_bookmark.exercise_log) assert exercise_count_after > exercise_count_before
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 _create_model_object(self): random_outcome = OutcomeRule().random random_source = SourceRule().random random_speed = random.randint(500, 5000) random_time = self.faker.date_time_this_month() new_exercise = Exercise(random_outcome, random_source, random_speed, random_time) if self._exists_in_db(new_exercise): return self._create_model_object() return new_exercise
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_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