def test_handle_wanikani_level_down_correctly_deletes_invalid_reviews(
self):
self.user.profile.level = 5
self.user.profile.save()
self.user.profile.unlocked_levels.get_or_create(level=5)
#Create a review at current levelwait,
vocab = create_vocab("ANY WORD")
create_reading(vocab, "some reading", "some char",
self.user.profile.level)
create_userspecific(vocab, self.user)
self.user.profile.handle_wanikani_level_change(
self.user.profile.level - 1)
reviews = UserSpecific.objects.filter(user=self.user)
self.assertTrue(reviews.count() == 1)
def setUp(self):
self.client = Client()
self.user = create_user("Tadgh")
self.user.set_password("password")
create_profile(self.user, "any key", 1)
self.user.save()
self.vocabulary = create_vocab("cat")
self.review = create_userspecific(self.vocabulary, self.user)
self.review.meaningsynonym_set.get_or_create(text="minou")
def test_get_all_readings_returns_original_and_added_readings(self):
self.vocabulary.readings.create(kana="what", character="ars", level=5)
review = create_userspecific(self.vocabulary, self.user)
review.answer_synonyms.create(kana="shwoop", character="fwoop")
expected = list(
chain(self.vocabulary.readings.all(),
review.answer_synonyms.all()))
self.assertListEqual(expected, review.get_all_readings())
def setUp(self):
self.user = create_user("user1")
self.user.set_password("password")
self.user.save()
create_profile(self.user, "some_key", 5)
# create a piece of vocab with one reading.
self.vocabulary = create_vocab("cat")
self.cat_reading = create_reading(self.vocabulary, "kana", "kanji", 5)
self.review = create_userspecific(self.vocabulary, self.user)
self.factory = RequestFactory()
def test_review_page_shows_all_items_when_burnt_setting_is_disabled(self):
word = create_vocab("phlange")
self.user.profile.only_review_burned = False
self.user.profile.save()
another_review = create_userspecific(word, self.user)
another_review.wanikani_burned = True
another_review.save()
response = self.client.get(reverse("kw:review"))
self.assertContains(response, "radioactive bat")
self.assertContains(response, "phlange")
def test_returning_review_count_that_is_time_delimited_functions_correctly(self):
new_review = create_userspecific(create_vocab("arbitrary word"), self.user)
new_review.needs_review = False
more_than_24_hours_from_now = timezone.now() + timedelta(hours=25)
new_review.next_review_date = more_than_24_hours_from_now
new_review.save()
self.review.next_review_date = timezone.now()
self.review.needs_review = False
self.review.save()
future_reviews = get_users_future_reviews(self.user, time_limit=timedelta(hours=24))
self.assertEqual(future_reviews.count(), 1)
def test_recording_answer_works_on_correct_answer(self):
us = create_userspecific(self.vocabulary, self.user)
self.client.post(
reverse("kw:record_answer"), {
'user_correct': "true",
'user_specific_id': us.id,
'wrong_before': 'false'
})
us.refresh_from_db()
recorded_properly = us.correct == 1 and us.streak == 1 and us.needs_review is False
self.assertTrue(recorded_properly)
def setUp(self):
self.user = create_user("user1")
self.user.set_password("password")
self.user.save()
create_profile(self.user, "some_key", 5)
# create a piece of vocab with one reading.
self.vocabulary = create_vocab("radioactive bat")
self.cat_reading = create_reading(self.vocabulary, "kana", "kanji", 5)
# setup a review with two synonyms
self.review = create_userspecific(self.vocabulary, self.user)
self.client = Client()
self.client.login(username="******", password="******")
def test_burnt_items_arent_included_when_getting_next_review_date(self):
current_time = timezone.now()
self.review.next_review_date = current_time
self.review.needs_review = False
self.review.save()
older_burnt_review = create_userspecific(create_vocab("test"),
self.user)
older_burnt_review.burned = True
older_burnt_review.needs_review = False
an_hour_ago = current_time - timedelta(hours=1)
older_burnt_review.next_review_date = an_hour_ago
older_burnt_review.save()
response = self.client.get("/kw/")
self.assertEqual(response.context['next_review_date'], current_time)
def test_wrong_answer_records_failure(self):
vocab = create_vocab("dog")
us = create_userspecific(vocab, self.user)
self.client.post(
reverse("kw:record_answer"), {
'user_correct': "false",
'user_specific_id': us.id,
'wrong_before': 'false'
})
us.refresh_from_db()
recorded_properly = (us.incorrect == 1 and us.streak == 0
and us.needs_review is True)
self.assertTrue(recorded_properly)
def test_synonym_adding(self):
review = create_userspecific(self.vocabulary, self.user)
review.meaningsynonym_set.get_or_create(text="kitty")
self.assertIn("kitty", review.synonyms_string())
def test_default_review_times_are_not_rounded(self):
rounded_time = self.review.next_review_date
new_vocab = create_userspecific(create_vocab("fresh"), self.user)
self.assertNotEqual(rounded_time, new_vocab.next_review_date)
def setUp(self):
self.user = create_user("Tadgh")
create_profile(self.user, "any_key", 5)
self.vocabulary = create_vocab("radioactive bat")
self.reading = create_reading(self.vocabulary, "ねこ", "猫", 2)
self.review = create_userspecific(self.vocabulary, self.user)
