def test_add_card(self):
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "What is it?"
card_answer = "This is that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# There is no card shown on deck page.
deck = Deck.objects.all()[0]
r = self.client.get("/deck/%s/show/" % deck.id)
self.assertNotIn(card_question, r.content)
self.assertNotIn(card_answer, r.content)
# There are now no cards in database.
self.assertEqual(len(Card.objects.all()), 0)
# Add new card.
r = add_card(self.client, deck.id, card_question, card_answer)
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
# There is now one card in database.
self.assertEqual(len(Card.objects.all()), 1)
# Card is also shown on deck page.
r = self.client.get("/deck/%s/show/" % deck.id)
self.assertIn(card_question, r.content)
self.assertIn(card_answer, r.content)
def test_count_cards_of_deck_tests(self):
"""User can see on deck page how many cards
are placed in specific deck."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "Is?"
card_answer = "Yes"
# Add shelf, deck and card.
add_shelf(self.client, shelf_name)
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
deck = Deck.objects.all()[0]
# There are no cards in deck yet.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertIn("(0)", r.content)
# Now there card is added.
add_card(self.client, deck.id, card_question, card_answer)
# There is one card in deck.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertNotIn("(0)", r.content)
self.assertIn("(1)", r.content)
def test_start_training_when_there_are_no_cards(self):
"""Session is not created when there are no cards to train."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
deck = Deck.objects.all()[0]
# Start shelf.
self.client.get("/user/shelf/%s/start/" % shelf.id)
# Train a deck with no cards there.
r = self.client.get("/user/deck/%s/train/" % deck.id, follow=True)
self.assertEqual(r.status_code, 200)
# Train pool was created.
trainpools = TrainPool.objects.all()
self.assertEqual(len(trainpools), 1)
# But train session not because there are no cards in train pool.
trainsessions = TrainSession.objects.all()
self.assertEqual(len(trainsessions), 0)
def test_edit_deck(self):
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
new_deck_name = "New deck name"
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# There is one deck in database.
self.assertEqual(len(Deck.objects.all()), 1)
# Deck is shown on shelf page.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertIn(deck_name, r.content)
# Edit deck.
deck = Deck.objects.all()[0]
remember_deck_id = deck.id
r = self.client.post("/deck/%s/edit/" % deck.id,
{"name": new_deck_name})
deck = Deck.objects.all()[0]
# Id of edited deck has not changed.
self.assertEqual(remember_deck_id, deck.id)
# Edited deck is shown on shelf page.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertNotIn(deck_name, r.content)
self.assertIn(new_deck_name, r.content)
# The number of decks is still one in database.
self.assertEqual(len(Deck.objects.all()), 1)
def test_max_number_of_cards_for_session(self):
"""For one session maximum 10 cards are chosen."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "What is it?"
card_answer = "This is that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# Add card.
deck = Deck.objects.all()[0]
# Add 20 cards.
for i in range(20):
add_card(self.client,
deck.id,
card_question + str(i),
card_answer)
# Start shelf.
self.client.get("/user/shelf/%s/start/" % shelf.id)
# Start deck training.
self.client.get("/user/deck/%s/train/" % deck.id)
# Maximum 10 cards are in this session.
trainsessions = TrainSession.objects.all()
session = trainsessions[0]
traincards_of_session = session.train_cards.split(",")
self.assertEqual(len(traincards_of_session), 10)
def test_train_or_continue_session(self):
"""If user started session then he will see continue session instead
of train on shelf page."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "What is it?"
card_answer = "This is that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# Add card.
deck = Deck.objects.all()[0]
add_card(self.client, deck.id, card_question, card_answer)
# Start shelf.
self.client.get("/user/shelf/%s/start/" % shelf.id)
# User didn't start session so there is shown Train link.
r = self.client.get("/user/shelf/%s/show/" % shelf.id)
self.assertIn("Train", r.content)
self.assertNotIn("Continue session", r.content)
# Train a new deck.
self.client.get("/user/deck/%s/train/" % deck.id)
# User started session so there is shown only Continue session link.
r = self.client.get("/user/shelf/%s/show/" % shelf.id)
self.assertNotIn("Train", r.content)
self.assertIn("Continue session", r.content)
def test_try_to_see_deck_page_before_starting_training(self):
"""If the user started shelf with deck but he didn't
start to train the deck then he shouldn't see the deck page."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "What is it?"
card_answer = "This is that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# Add card.
deck = Deck.objects.all()[0]
add_card(self.client, deck.id, card_question, card_answer)
# Start shelf.
self.client.get("/user/shelf/%s/start/" % shelf.id)
# Then user tries to see deck page for shelf -
# but he didn't start training so 404 is returned.
r = self.client.get("/user/deck/%s/show/" % deck.id)
self.assertEqual(r.status_code, HttpResponseNotFound.status_code)
# Then user starts the training and training pool
# is created this time.
r = self.client.get("/user/deck/%s/train/" % deck.id)
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
# And user after starting training and creation of
# training pool can view deck page.
r = self.client.get("/user/deck/%s/show/" % deck.id)
self.assertEqual(r.status_code, 200)
def test_order_of_decks_is_taken_into_account(self):
"""Order of decks is kept in XML dump so that decks are sorted
by order."""
add_shelf(self.client, "first shelf")
# Add decks.
all_shelves = Shelf.objects.all()
add_deck(self.client, all_shelves[0].id, "first deck")
add_deck(self.client, all_shelves[0].id, "second deck")
all_decks = Deck.objects.all()
# Move first shelf up.
self.client.get("/deck/%d/move/up/" % all_decks[0].id)
# Second shelf is listed as first and first shelf is listed as second.
r = self.client.get("/data/dump/")
c = ("""<?xml version='1.0' encoding='UTF-8'?>\n"""
"""<data>\n"""
""" <shelf name="first shelf">\n"""
""" <deck name="second deck"/>\n"""
""" <deck name="first deck"/>\n"""
""" </shelf>\n"""
"""</data>\n""")
self.assertEqual(c, r.content)
def test_order_of_decks_is_taken_into_account(self):
"""Order of decks is kept in XML dump so that decks are sorted
by order."""
add_shelf(self.client, "first shelf")
# Add decks.
all_shelves = Shelf.objects.all()
add_deck(self.client, all_shelves[0].id, "first deck")
add_deck(self.client, all_shelves[0].id, "second deck")
all_decks = Deck.objects.all()
# Move first shelf up.
self.client.get("/deck/%d/move/up/" % all_decks[0].id)
# Second shelf is listed as first and first shelf is listed as second.
r = self.client.get("/data/dump/")
c = ("""<?xml version='1.0' encoding='UTF-8'?>\n"""
"""<data>\n"""
""" <shelf name="first shelf">\n"""
""" <deck name="second deck"/>\n"""
""" <deck name="first deck"/>\n"""
""" </shelf>\n"""
"""</data>\n""")
self.assertEqual(c, r.content)
def test_count_cards_of_deck_tests(self):
"""User can see on deck page how many cards
are placed in specific deck."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "Is?"
card_answer = "Yes"
# Add shelf, deck and card.
add_shelf(self.client, shelf_name)
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
deck = Deck.objects.all()[0]
# There are no cards in deck yet.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertIn("(0)", r.content)
# Now there card is added.
add_card(self.client, deck.id, card_question, card_answer)
# There is one card in deck.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertNotIn("(0)", r.content)
self.assertIn("(1)", r.content)
def test_edit_deck(self):
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
new_deck_name = "New deck name"
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# There is one deck in database.
self.assertEqual(len(Deck.objects.all()), 1)
# Deck is shown on shelf page.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertIn(deck_name, r.content)
# Edit deck.
deck = Deck.objects.all()[0]
remember_deck_id = deck.id
r = self.client.post("/deck/%s/edit/" % deck.id,
{"name": new_deck_name})
deck = Deck.objects.all()[0]
# Id of edited deck has not changed.
self.assertEqual(remember_deck_id, deck.id)
# Edited deck is shown on shelf page.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertNotIn(deck_name, r.content)
self.assertIn(new_deck_name, r.content)
# The number of decks is still one in database.
self.assertEqual(len(Deck.objects.all()), 1)
def test_start_training_session_index_only_increases_after_answer(self):
"""Only when answer is given then index of session with new card
increases."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question1 = "What is it?"
card_answer1 = "This is that."
card_question2 = "What was it?"
card_answer2 = "This was that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# Add two cards.
deck = Deck.objects.all()[0]
add_card(self.client, deck.id, card_question1, card_answer1)
add_card(self.client, deck.id, card_question2, card_answer2)
# Start shelf.
self.client.get("/user/shelf/%s/start/" % shelf.id)
# Train a new deck.
self.client.get("/user/deck/%s/train/" % deck.id)
# One session was started.
trainsessions = TrainSession.objects.all()
session = trainsessions[0]
self.assertEqual(len(trainsessions), 1)
# Figure out which card was now chosen.
r = self.client.get("/user/train/session/%s/" % session.id)
if card_question1 in r.content:
current_question = card_question1
next_question = card_question2
else:
current_question = card_question2
next_question = card_question1
self.assertIn(current_question, r.content)
# Check if the same question was shown if no answer was given.
r = self.client.get("/user/train/session/%s/" % session.id)
self.assertIn(current_question, r.content)
# Answer was given so next question is now shown.
r = self.client.post("/user/train/session/%s/" % session.id,
{"Answer": "Bad"})
self.assertIn(next_question, r.content)
# Answer is given and training session is finished.
self.client.post("/user/train/session/%s/" % session.id,
{"Answer": "Good"})
# No train sessions are present.
trainsessions = TrainSession.objects.all()
self.assertEqual(len(trainsessions), 0)
def test_delete_deck(self):
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
r = add_deck(self.client, shelf.id, deck_name)
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
# There is now one deck in database.
self.assertEqual(len(Deck.objects.all()), 1)
# The deck is shown on shelf page.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertIn(deck_name, r.content)
# Delete deck.
deck = Deck.objects.all()[0]
r = self.client.get("/deck/%s/delete/" % deck.id)
# The deck is now not shown on shelf page.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertNotIn(deck_name, r.content)
# There are now no decks in database.
self.assertEqual(len(Deck.objects.all()), 0)
def test_delete_deck(self):
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
r = add_deck(self.client, shelf.id, deck_name)
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
# There is now one deck in database.
self.assertEqual(len(Deck.objects.all()), 1)
# The deck is shown on shelf page.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertIn(deck_name, r.content)
# Delete deck.
deck = Deck.objects.all()[0]
r = self.client.get("/deck/%s/delete/" % deck.id)
# The deck is now not shown on shelf page.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertNotIn(deck_name, r.content)
# There are now no decks in database.
self.assertEqual(len(Deck.objects.all()), 0)
def test_add_deck(self):
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
add_shelf(self.client, shelf_name)
# Deck is not shown on shelf page.
shelf = Shelf.objects.all()[0]
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertNotIn(deck_name, r.content)
# Add deck.
r = add_deck(self.client, shelf.id, deck_name)
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
# There is one deck in database.
self.assertEqual(len(Deck.objects.all()), 1)
# Shelf is assigned to the deck.
deck = Deck.objects.all()[0]
self.assertEqual(deck.shelf.id, shelf.id)
self.assertEqual(deck.name, deck_name)
# First deck has order 0 which means that it's first.
self.assertEqual(deck.order, 0)
# Deck is shown on shelf page.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertIn(deck_name, r.content)
def test_add_deck(self):
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
add_shelf(self.client, shelf_name)
# Deck is not shown on shelf page.
shelf = Shelf.objects.all()[0]
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertNotIn(deck_name, r.content)
# Add deck.
r = add_deck(self.client, shelf.id, deck_name)
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
# There is one deck in database.
self.assertEqual(len(Deck.objects.all()), 1)
# Shelf is assigned to the deck.
deck = Deck.objects.all()[0]
self.assertEqual(deck.shelf.id, shelf.id)
self.assertEqual(deck.name, deck_name)
# First deck has order 0 which means that it's first.
self.assertEqual(deck.order, 0)
# Deck is shown on shelf page.
r = self.client.get("/shelf/%s/show/" % shelf.id)
self.assertIn(deck_name, r.content)
def test_start_training_and_check_answer_time_on_wrong_answer(self):
"""When the answer for question is wrong then new time to show for
card is not calculated."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "What is it?"
card_answer = "This is that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# Add card.
deck = Deck.objects.all()[0]
add_card(self.client, deck.id, card_question, card_answer)
# Start shelf.
self.client.get("/user/shelf/%s/start/" % shelf.id)
# Train a new deck.
r = self.client.get("/user/deck/%s/train/" % deck.id)
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
# Get current session and time to show for card.
trainsessions = TrainSession.objects.all()
session = trainsessions[0]
traincards = TrainCard.objects.all()
traincard = traincards[0]
time_to_show = traincard.time_to_show
# Check first question.
r = self.client.get("/user/train/session/%s/" % session.id)
self.assertIn(card_question, r.content)
# Answer good on first question.
self.client.post("/user/train/session/%s/" % session.id,
{"Answer": "Bad"})
# Get newer calculated time to show for card.
traincards = TrainCard.objects.all()
traincard = traincards[0]
new_time_to_show = traincard.time_to_show
# Check that new time to show is greater than old time to show.
self.assertTrue(new_time_to_show == time_to_show)
def test_edit_card(self):
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "What is it?"
card_answer = "This is that."
new_card_question = "Why so?"
new_card_answer = "No idea"
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# Add card.
deck = Deck.objects.all()[0]
add_card(self.client, deck.id, card_question, card_answer)
# Only this card is in database.
cards = Card.objects.all()
card = cards[0]
self.assertEqual(len(cards), 1)
# Check if card is shown on deck page.
r = self.client.get("/deck/%s/show/" % deck.id)
self.assertIn(card_question, r.content)
self.assertIn(card_answer, r.content)
# Edit card.
r = self.client.post("/card/%s/edit/" % card.id,
{"question": new_card_question,
"answer": new_card_answer})
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
# Edited card is shown on deck page.
r = self.client.get("/deck/%s/show/" % deck.id)
self.assertNotIn(card_question, r.content)
self.assertNotIn(card_answer, r.content)
self.assertIn(new_card_question, r.content)
self.assertIn(new_card_answer, r.content)
# The number of card objects should not change.
self.assertEqual(len(Card.objects.all()), 1)
def test_add_card_with_empty_question(self):
"""Question and answer for the card cannot be empty."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = ""
card_answer = "This is that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# Get deck.
deck = Deck.objects.all()[0]
# Add new card.
r = add_card(self.client, deck.id, card_question, card_answer)
self.assertIn("This field is required.", r.content)
def test_delete_decks_and_check_order(self):
shelf_name = "Some nice shelf"
first_deck_name = "First deck"
second_deck_name = "Second deck"
third_deck_name = "Third deck"
add_shelf(self.client, shelf_name)
# Add decks.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, first_deck_name)
add_deck(self.client, shelf.id, second_deck_name)
add_deck(self.client, shelf.id, third_deck_name)
all_decks = Deck.objects.all()
self.assertEqual(len(all_decks), 3)
# Delete deck in the middle.
self.client.get("/deck/%d/delete/" % all_decks[1].id)
all_decks = Deck.objects.all()
# Order of last deck (third deck) was decreased in order
# to achieve continuity.
self.assertEqual(len(all_decks), 2)
self.assertEqual(all_decks[0].order, 0)
self.assertEqual(all_decks[0].name, first_deck_name)
self.assertEqual(all_decks[1].order, 1)
self.assertEqual(all_decks[1].name, third_deck_name)
def test_user_cannot_perform_sessions_of_other_users(self):
"""If two users train the same deck, they can't have access
to the sessions of each other."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "What is it?"
card_answer = "This is that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# Add card.
deck = Deck.objects.all()[0]
add_card(self.client, deck.id, card_question, card_answer)
# Start shelf.
self.client.get("/user/shelf/%s/start/" % shelf.id)
# Train a new deck.
r = self.client.get("/user/deck/%s/train/" % deck.id)
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
# Train session and get correct result because this user started it.
trainsessions = TrainSession.objects.all()
session = trainsessions[0]
r = self.client.get("/user/train/session/%s/" % session.id)
self.assertEqual(r.status_code, 200)
# Login as other user.
UserProfile.objects.create_user(username="******", password="******")
self.client.logout()
self.client.login(username="******", password="******")
# Try to train session of other user - it's forbidden.
r = self.client.get("/user/train/session/%s/" % session.id)
self.assertEqual(r.status_code, HttpResponseForbidden.status_code)
def test_delete_decks_and_check_order(self):
shelf_name = "Some nice shelf"
first_deck_name = "First deck"
second_deck_name = "Second deck"
third_deck_name = "Third deck"
add_shelf(self.client, shelf_name)
# Add decks.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, first_deck_name)
add_deck(self.client, shelf.id, second_deck_name)
add_deck(self.client, shelf.id, third_deck_name)
all_decks = Deck.objects.all()
self.assertEqual(len(all_decks), 3)
# Delete deck in the middle.
self.client.get("/deck/%d/delete/" % all_decks[1].id)
all_decks = Deck.objects.all()
# Order of last deck (third deck) was decreased in order
# to achieve continuity.
self.assertEqual(len(all_decks), 2)
self.assertEqual(all_decks[0].order, 0)
self.assertEqual(all_decks[0].name, first_deck_name)
self.assertEqual(all_decks[1].order, 1)
self.assertEqual(all_decks[1].name, third_deck_name)
def test_question_and_answer_use_markdown(self):
"""Markdown is used to make text looking nicer."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "**What is it?**"
card_answer = ("~~~~{.python}\n"
"import os\n"
"~~~~")
# Add shelf, deck and card.
add_shelf(self.client, shelf_name)
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
deck = Deck.objects.all()[0]
add_card(self.client, deck.id, card_question, card_answer)
# Text is processed by Markdown - ** is transformed to strong and
# code listing is appropriately formatted.
r = self.client.get("/deck/%s/show/" % deck.id)
self.assertIn("<strong>What is it?</strong>", r.content)
self.assertIn('<div class="codehilite"><pre><span class="kn">'
'import</span> <span class="nn">os</span>\n</pre>'
'</div>', r.content)
def test_train_all_option_gets_all_cards_in_session(self):
"""Except normal train session which gets in session max
10 cards, there is also an option to train all cards which
will create session with all cards in given deck.."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "What is it?"
card_answer = "This is that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# Add card.
deck = Deck.objects.all()[0]
# Add 20 cards.
for i in range(20):
add_card(self.client,
deck.id,
card_question + str(i),
card_answer)
# Start shelf.
self.client.get("/user/shelf/%s/start/" % shelf.id)
# Start deck training.
self.client.get("/user/deck/%s/train/all/" % deck.id)
# All 20 cards will be put in session.
trainsessions = TrainSession.objects.all()
session = trainsessions[0]
traincards_of_session = session.train_cards.split(",")
self.assertEqual(len(traincards_of_session), 20)
def test_delete_card(self):
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "What is it?"
card_answer = "This is that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# Add card.
deck = Deck.objects.all()[0]
add_card(self.client, deck.id, card_question, card_answer)
# Only this card is placed in database.
cards = Card.objects.all()
card = cards[0]
self.assertEqual(len(cards), 1)
# Check if card is shown on deck page.
r = self.client.get("/deck/%s/show/" % deck.id)
self.assertIn(card_question, r.content)
self.assertIn(card_answer, r.content)
# Delete card.
r = self.client.get("/card/%s/delete/" % card.id)
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
# Card is not visible on deck page.
r = self.client.get("/deck/%s/show/" % deck.id)
self.assertNotIn(card_question, r.content)
self.assertNotIn(card_answer, r.content)
# There are also no cards in database.
self.assertEqual(len(Card.objects.all()), 0)
def test_add_multiple_decks_and_check_order(self):
shelf_name = "Some nice shelf"
first_deck_name = "First deck"
second_deck_name = "Second deck"
third_deck_name = "Third deck"
add_shelf(self.client, shelf_name)
# Add decks.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, first_deck_name)
add_deck(self.client, shelf.id, second_deck_name)
add_deck(self.client, shelf.id, third_deck_name)
all_decks = Deck.objects.all()
# Each new added deck has order so it's maximum value
# of other orders + 1
self.assertEqual(all_decks[0].order, 0)
self.assertEqual(all_decks[1].order, 1)
self.assertEqual(all_decks[2].order, 2)
def test_add_multiple_decks_and_check_order(self):
shelf_name = "Some nice shelf"
first_deck_name = "First deck"
second_deck_name = "Second deck"
third_deck_name = "Third deck"
add_shelf(self.client, shelf_name)
# Add decks.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, first_deck_name)
add_deck(self.client, shelf.id, second_deck_name)
add_deck(self.client, shelf.id, third_deck_name)
all_decks = Deck.objects.all()
# Each new added deck has order so it's maximum value
# of other orders + 1
self.assertEqual(all_decks[0].order, 0)
self.assertEqual(all_decks[1].order, 1)
self.assertEqual(all_decks[2].order, 2)
def test_dump_and_load(self):
# Add shelves.
add_shelf(self.client, "1st shelf")
add_shelf(self.client, "2nd shelf><\"&")
add_shelf(self.client, "3rd shelf")
# Add decks.
all_shelves = Shelf.objects.all()
first_shelf = all_shelves[0]
add_deck(self.client, first_shelf.id, "1st shelf 1st deck><\"&")
add_deck(self.client, first_shelf.id, "1st shelf 2nd deck")
# Add some cards.
all_decks = Deck.objects.all()
first_shelf_first_deck = all_decks[0]
add_card(self.client, first_shelf_first_deck.id,
"1st deck 1st question><",
"1st deck 1st answer><\"&")
first_shelf_second_deck = all_decks[1]
add_card(self.client, first_shelf_second_deck.id,
"2nd deck 1st question",
"2nd deck 1st answer")
add_card(self.client, first_shelf_second_deck.id,
"2nd deck 2nd question",
"2nd deck 2nd answer")
all_cards = Card.objects.all()
# Check the number of added shelves, decks and cards.
self.assertEqual(len(all_cards), 3)
self.assertEqual(len(all_shelves), 3)
self.assertEqual(len(all_decks), 2)
# Remember shelves for next checks.
first_shelf = all_shelves[0]
second_shelf = all_shelves[1]
third_shelf = all_shelves[2]
# Remember decks for next checks.
first_shelf_first_deck = all_decks[0]
first_shelf_second_deck = all_decks[1]
# Remember questions for next checks.
first_deck_first_question = all_cards[0].question
first_deck_first_answer = all_cards[0].answer
second_deck_first_question = all_cards[1].question
second_deck_first_answer = all_cards[1].answer
second_deck_second_question = all_cards[2].question
second_deck_second_answer = all_cards[2].answer
# Check if correct XML file was generated.
r = self.client.get("/data/dump/")
c = ("""<?xml version='1.0' encoding='UTF-8'?>\n"""
"""<data>\n"""
""" <shelf name="1st shelf">\n"""
""" <deck name="1st shelf 1st deck><"&">\n"""
""" <card>\n"""
""" <question>1st deck 1st question><</question>\n"""
""" <answer>1st deck 1st answer><"&</answer>\n"""
""" </card>\n"""
""" </deck>\n"""
""" <deck name="1st shelf 2nd deck">\n"""
""" <card>\n"""
""" <question>2nd deck 1st question</question>\n"""
""" <answer>2nd deck 1st answer</answer>\n"""
""" </card>\n"""
""" <card>\n"""
""" <question>2nd deck 2nd question</question>\n"""
""" <answer>2nd deck 2nd answer</answer>\n"""
""" </card>\n"""
""" </deck>\n"""
""" </shelf>\n"""
""" <shelf name="2nd shelf><"&"/>\n"""
""" <shelf name="3rd shelf"/>\n"""
"""</data>\n""")
self.assertEqual(c, r.content)
self.assertEqual(200, r.status_code)
# Delete all shelves (with all decks and cards) from database.
shelves = Shelf.objects.all()
for shelf in shelves:
self.client.get("/shelf/%d/delete/" % shelf.id)
# Check if all cards were deleted.
self.assertEqual(len(Card.objects.all()), 0)
self.assertEqual(len(Shelf.objects.all()), 0)
self.assertEqual(len(Deck.objects.all()), 0)
# Load data from XML file back to database.
sent_file = SimpleUploadedFile("dump_data.xml", r.content)
r = self.client.post("/data/load/", {"data_dump_file": sent_file},
follow=True)
self.assertEqual(200, r.status_code)
all_shelves = Shelf.objects.all()
all_decks = Deck.objects.all()
all_cards = Card.objects.all()
# Check number of loaded cards from file.
self.assertEqual(len(all_cards), 3)
self.assertEqual(len(all_shelves), 3)
self.assertEqual(len(all_decks), 2)
# Check if loaded shelves are the same as previously
# located in database.
self.assertEqual(first_shelf, all_shelves[0])
self.assertEqual(second_shelf, all_shelves[1])
self.assertEqual(third_shelf, all_shelves[2])
# Check if loaded decks are the same as previously
# located in database.
self.assertEqual(first_shelf_first_deck, all_decks[0])
self.assertEqual(first_shelf_second_deck, all_decks[1])
# Check if loaded cards are the same as previously
# located in database.
self.assertEqual(first_deck_first_question,
all_cards[0].question)
self.assertEqual(first_deck_first_answer,
all_cards[0].answer)
self.assertEqual(second_deck_first_question,
all_cards[1].question)
self.assertEqual(second_deck_first_answer,
all_cards[1].answer)
self.assertEqual(second_deck_second_question,
all_cards[2].question)
self.assertEqual(second_deck_second_answer,
all_cards[2].answer)
# Check the structure.
# first shelf first deck
self.assertEqual(all_decks[0].shelf, all_shelves[0])
# first shelf second deck
self.assertEqual(all_decks[1].shelf, all_shelves[0])
# first shelf first deck first card
self.assertEqual(all_cards[0].deck, all_decks[0])
# first shelf second deck first card
self.assertEqual(all_cards[1].deck, all_decks[1])
# first shelf second deck second card
self.assertEqual(all_cards[2].deck, all_decks[1])
def test_move_deck_down(self):
shelf_name = "Some nice shelf"
first_deck_name = "First deck"
second_deck_name = "Second deck"
third_deck_name = "Third deck"
add_shelf(self.client, shelf_name)
# Add decks.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, first_deck_name)
add_deck(self.client, shelf.id, second_deck_name)
add_deck(self.client, shelf.id, third_deck_name)
all_decks = Deck.objects.all()
# Initial orders:
# 0 first deck
# 1 second deck
# 2 third deck
self.assertEqual(all_decks[0].order, 0)
self.assertEqual(all_decks[0].name, first_deck_name)
self.assertEqual(all_decks[1].order, 1)
self.assertEqual(all_decks[1].name, second_deck_name)
self.assertEqual(all_decks[2].order, 2)
self.assertEqual(all_decks[2].name, third_deck_name)
self.client.get("/deck/%d/move/down/" % all_decks[2].id)
all_decks = Deck.objects.all()
# Move third deck down:
# 0 first deck
# 1 third deck
# 2 second deck
self.assertEqual(all_decks[0].order, 0)
self.assertEqual(all_decks[0].name, first_deck_name)
self.assertEqual(all_decks[1].order, 2)
self.assertEqual(all_decks[1].name, second_deck_name)
self.assertEqual(all_decks[2].order, 1)
self.assertEqual(all_decks[2].name, third_deck_name)
self.client.get("/deck/%d/move/down/" % all_decks[2].id)
all_decks = Deck.objects.all()
# Move third deck down:
# 0 third deck
# 1 first deck
# 2 second deck
self.assertEqual(all_decks[0].order, 1)
self.assertEqual(all_decks[0].name, first_deck_name)
self.assertEqual(all_decks[1].order, 2)
self.assertEqual(all_decks[1].name, second_deck_name)
self.assertEqual(all_decks[2].order, 0)
self.assertEqual(all_decks[2].name, third_deck_name)
self.client.get("/deck/%d/move/down/" % all_decks[2].id)
all_decks = Deck.objects.all()
# Move third deck down (nothing will change because it's already
# on bottom):
# 0 third deck
# 1 first deck
# 2 second deck
self.assertEqual(all_decks[0].order, 1)
self.assertEqual(all_decks[0].name, first_deck_name)
self.assertEqual(all_decks[1].order, 2)
self.assertEqual(all_decks[1].name, second_deck_name)
self.assertEqual(all_decks[2].order, 0)
self.assertEqual(all_decks[2].name, third_deck_name)
def test_move_deck_down(self):
shelf_name = "Some nice shelf"
first_deck_name = "First deck"
second_deck_name = "Second deck"
third_deck_name = "Third deck"
add_shelf(self.client, shelf_name)
# Add decks.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, first_deck_name)
add_deck(self.client, shelf.id, second_deck_name)
add_deck(self.client, shelf.id, third_deck_name)
all_decks = Deck.objects.all()
# Initial orders:
# 0 first deck
# 1 second deck
# 2 third deck
self.assertEqual(all_decks[0].order, 0)
self.assertEqual(all_decks[0].name, first_deck_name)
self.assertEqual(all_decks[1].order, 1)
self.assertEqual(all_decks[1].name, second_deck_name)
self.assertEqual(all_decks[2].order, 2)
self.assertEqual(all_decks[2].name, third_deck_name)
self.client.get("/deck/%d/move/down/" % all_decks[2].id)
all_decks = Deck.objects.all()
# Move third deck down:
# 0 first deck
# 1 third deck
# 2 second deck
self.assertEqual(all_decks[0].order, 0)
self.assertEqual(all_decks[0].name, first_deck_name)
self.assertEqual(all_decks[1].order, 2)
self.assertEqual(all_decks[1].name, second_deck_name)
self.assertEqual(all_decks[2].order, 1)
self.assertEqual(all_decks[2].name, third_deck_name)
self.client.get("/deck/%d/move/down/" % all_decks[2].id)
all_decks = Deck.objects.all()
# Move third deck down:
# 0 third deck
# 1 first deck
# 2 second deck
self.assertEqual(all_decks[0].order, 1)
self.assertEqual(all_decks[0].name, first_deck_name)
self.assertEqual(all_decks[1].order, 2)
self.assertEqual(all_decks[1].name, second_deck_name)
self.assertEqual(all_decks[2].order, 0)
self.assertEqual(all_decks[2].name, third_deck_name)
self.client.get("/deck/%d/move/down/" % all_decks[2].id)
all_decks = Deck.objects.all()
# Move third deck down (nothing will change because it's already
# on bottom):
# 0 third deck
# 1 first deck
# 2 second deck
self.assertEqual(all_decks[0].order, 1)
self.assertEqual(all_decks[0].name, first_deck_name)
self.assertEqual(all_decks[1].order, 2)
self.assertEqual(all_decks[1].name, second_deck_name)
self.assertEqual(all_decks[2].order, 0)
self.assertEqual(all_decks[2].name, third_deck_name)
def test_add_deck(self):
self.assertEqual(len(Deck.objects.all()), 0)
r = add_deck(self.client, 777, "Some Deck")
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
self.assertIn("login", r.get("location"))
self.assertEqual(len(Deck.objects.all()), 0)
def test_add_card_with_the_same_question_to_one_deck(self):
"""For one deck card questions must be unique. However
different decks can have cards with the same questions."""
shelf_name = "Some nice shelf"
deck_name1 = "Some nice deck"
deck_name2 = "Some other deck"
card_question = "What is it?"
card_answer = "This is that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name1)
# Add some card.
deck1 = Deck.objects.all()[0]
add_card(self.client, deck1.id, card_question, card_answer)
self.assertEqual(len(Card.objects.all()), 1)
# Try to add another card with the same question to the same deck.
# It is forbidden.
r = add_card(self.client, deck1.id, card_question, card_answer)
self.assertIn(("The question for this card already exists"
" in this deck."),
r.content)
self.assertEqual(len(Card.objects.all()), 1)
# Try to add another card with similar question but with
# some trailing whitespaces. Question will be stripped
# and the card will be not added.
r = add_card(self.client, deck1.id, " What is it? \n ",
card_answer)
self.assertIn(("The question for this card already exists"
" in this deck."),
r.content)
self.assertEqual(len(Card.objects.all()), 1)
# Try to edit the same card without changing question.
# It should pass - there is still only one card in the deck
# with this question.
cards = Card.objects.all()
card = cards[0]
r = self.client.post("/card/%s/edit/" % card.id,
{"question": card_question,
"answer": card_answer}, follow=True)
self.assertNotIn(("The question for this card already exists"
" in this deck."),
r.content)
# Add some another card successfully.
add_card(self.client, deck1.id, "Yeyeye", card_answer)
self.assertEqual(len(Card.objects.all()), 2)
# Try to edit previous card with the question the same like
# in new card just added - it should fail.
r = self.client.post("/card/%s/edit/" % card.id,
{"question": "Yeyeye",
"answer": card_answer})
self.assertIn(("The question for this card already exists"
" in this deck."),
r.content)
# Add another deck.
add_deck(self.client, shelf.id, deck_name2)
deck2 = Deck.objects.all()[1]
# Try to add new card with the same question like in previous card
# but previous card was added to DIFFERENT deck. It should
# be ok.
r = add_card(self.client, deck2.id, card_question, card_answer)
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
self.assertEqual(len(Card.objects.all()), 3)
# Two cards with the same pair question and answer should be not
# placed in database.
card = Card(question="What is it?",
answer="This is that.",
deck=deck1)
self.assertRaises(IntegrityError, card.save)
def test_dump_and_load(self):
# Add shelves.
add_shelf(self.client, "1st shelf")
add_shelf(self.client, "2nd shelf><\"&")
add_shelf(self.client, "3rd shelf")
# Add decks.
all_shelves = Shelf.objects.all()
first_shelf = all_shelves[0]
add_deck(self.client, first_shelf.id, "1st shelf 1st deck><\"&")
add_deck(self.client, first_shelf.id, "1st shelf 2nd deck")
# Add some cards.
all_decks = Deck.objects.all()
first_shelf_first_deck = all_decks[0]
add_card(self.client, first_shelf_first_deck.id,
"1st deck 1st question><", "1st deck 1st answer><\"&")
first_shelf_second_deck = all_decks[1]
add_card(self.client, first_shelf_second_deck.id,
"2nd deck 1st question", "2nd deck 1st answer")
add_card(self.client, first_shelf_second_deck.id,
"2nd deck 2nd question", "2nd deck 2nd answer")
all_cards = Card.objects.all()
# Check the number of added shelves, decks and cards.
self.assertEqual(len(all_cards), 3)
self.assertEqual(len(all_shelves), 3)
self.assertEqual(len(all_decks), 2)
# Remember shelves for next checks.
first_shelf = all_shelves[0]
second_shelf = all_shelves[1]
third_shelf = all_shelves[2]
# Remember decks for next checks.
first_shelf_first_deck = all_decks[0]
first_shelf_second_deck = all_decks[1]
# Remember questions for next checks.
first_deck_first_question = all_cards[0].question
first_deck_first_answer = all_cards[0].answer
second_deck_first_question = all_cards[1].question
second_deck_first_answer = all_cards[1].answer
second_deck_second_question = all_cards[2].question
second_deck_second_answer = all_cards[2].answer
# Check if correct XML file was generated.
r = self.client.get("/data/dump/")
c = ("""<?xml version='1.0' encoding='UTF-8'?>\n"""
"""<data>\n"""
""" <shelf name="1st shelf">\n"""
""" <deck name="1st shelf 1st deck><"&">\n"""
""" <card>\n"""
""" <question>1st deck 1st question><</question>\n"""
""" <answer>1st deck 1st answer><"&</answer>\n"""
""" </card>\n"""
""" </deck>\n"""
""" <deck name="1st shelf 2nd deck">\n"""
""" <card>\n"""
""" <question>2nd deck 1st question</question>\n"""
""" <answer>2nd deck 1st answer</answer>\n"""
""" </card>\n"""
""" <card>\n"""
""" <question>2nd deck 2nd question</question>\n"""
""" <answer>2nd deck 2nd answer</answer>\n"""
""" </card>\n"""
""" </deck>\n"""
""" </shelf>\n"""
""" <shelf name="2nd shelf><"&"/>\n"""
""" <shelf name="3rd shelf"/>\n"""
"""</data>\n""")
self.assertEqual(c, r.content)
self.assertEqual(200, r.status_code)
# Delete all shelves (with all decks and cards) from database.
shelves = Shelf.objects.all()
for shelf in shelves:
self.client.get("/shelf/%d/delete/" % shelf.id)
# Check if all cards were deleted.
self.assertEqual(len(Card.objects.all()), 0)
self.assertEqual(len(Shelf.objects.all()), 0)
self.assertEqual(len(Deck.objects.all()), 0)
# Load data from XML file back to database.
sent_file = SimpleUploadedFile("dump_data.xml", r.content)
r = self.client.post("/data/load/", {"data_dump_file": sent_file},
follow=True)
self.assertEqual(200, r.status_code)
all_shelves = Shelf.objects.all()
all_decks = Deck.objects.all()
all_cards = Card.objects.all()
# Check number of loaded cards from file.
self.assertEqual(len(all_cards), 3)
self.assertEqual(len(all_shelves), 3)
self.assertEqual(len(all_decks), 2)
# Check if loaded shelves are the same as previously
# located in database.
self.assertEqual(first_shelf, all_shelves[0])
self.assertEqual(second_shelf, all_shelves[1])
self.assertEqual(third_shelf, all_shelves[2])
# Check if loaded decks are the same as previously
# located in database.
self.assertEqual(first_shelf_first_deck, all_decks[0])
self.assertEqual(first_shelf_second_deck, all_decks[1])
# Check if loaded cards are the same as previously
# located in database.
self.assertEqual(first_deck_first_question, all_cards[0].question)
self.assertEqual(first_deck_first_answer, all_cards[0].answer)
self.assertEqual(second_deck_first_question, all_cards[1].question)
self.assertEqual(second_deck_first_answer, all_cards[1].answer)
self.assertEqual(second_deck_second_question, all_cards[2].question)
self.assertEqual(second_deck_second_answer, all_cards[2].answer)
# Check the structure.
# first shelf first deck
self.assertEqual(all_decks[0].shelf, all_shelves[0])
# first shelf second deck
self.assertEqual(all_decks[1].shelf, all_shelves[0])
# first shelf first deck first card
self.assertEqual(all_cards[0].deck, all_decks[0])
# first shelf second deck first card
self.assertEqual(all_cards[1].deck, all_decks[1])
# first shelf second deck second card
self.assertEqual(all_cards[2].deck, all_decks[1])
def test_add_deck(self):
self.assertEqual(len(Deck.objects.all()), 0)
r = add_deck(self.client, 777, "Some Deck")
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
self.assertIn("login", r.get("location"))
self.assertEqual(len(Deck.objects.all()), 0)
def test_calculate_interval_time(self):
"""Time calculations for right and wrong answer."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "What is it?"
card_answer = "This is that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
deck = Deck.objects.all()[0]
# Add some card.
add_card(self.client, deck.id, card_question, card_answer)
# Start shelf.
self.client.get("/user/shelf/%s/start/" % shelf.id)
# Start deck training.
self.client.get("/user/deck/%s/train/" % deck.id)
traincards = TrainCard.objects.all()
traincard = traincards[0]
now = datetime.datetime.now()
# Answer correct.
traincard.calculate_interval(5)
new_time_to_show = traincard.time_to_show
time_deleta_in_seconds = (new_time_to_show - now).seconds
time_deleta_in_minutes = time_deleta_in_seconds / 60
self.assertEqual(time_deleta_in_minutes, 24)
# Answer correct.
traincard.calculate_interval(5)
new_time_to_show = traincard.time_to_show
time_deleta_in_seconds = (new_time_to_show - now).seconds
time_deleta_in_minutes = time_deleta_in_seconds / 60
self.assertEqual(time_deleta_in_minutes, 144)
# Answer correct.
traincard.calculate_interval(5)
new_time_to_show = traincard.time_to_show
time_deleta_in_seconds = (new_time_to_show - now).seconds
time_deleta_in_minutes = time_deleta_in_seconds / 60
self.assertEqual(time_deleta_in_minutes, 403)
# Answer wrong - time is not calculated.
traincard.calculate_interval(0)
new_time_to_show = traincard.time_to_show
time_deleta_in_seconds = (new_time_to_show - now).seconds
time_deleta_in_minutes = time_deleta_in_seconds / 60
self.assertEqual(time_deleta_in_minutes, 403)
# Answer correct.
traincard.calculate_interval(5)
new_time_to_show = traincard.time_to_show
time_deleta_in_seconds = (new_time_to_show - now).seconds
time_deleta_in_minutes = time_deleta_in_seconds / 60
self.assertEqual(time_deleta_in_minutes, 24)
# Answer correct.
traincard.calculate_interval(5)
new_time_to_show = traincard.time_to_show
time_deleta_in_seconds = (new_time_to_show - now).seconds
time_deleta_in_minutes = time_deleta_in_seconds / 60
self.assertEqual(time_deleta_in_minutes, 144)
# Answer correct.
traincard.calculate_interval(5)
new_time_to_show = traincard.time_to_show
time_deleta_in_seconds = (new_time_to_show - now).seconds
time_deleta_in_minutes = time_deleta_in_seconds / 60
self.assertEqual(time_deleta_in_minutes, 446)
# Answer correct.
traincard.calculate_interval(5)
new_time_to_show = traincard.time_to_show
time_deleta_in_seconds = (new_time_to_show - now).seconds
time_deleta_in_minutes = time_deleta_in_seconds / 60
self.assertEqual(time_deleta_in_minutes, 1428)
# Answer wrong - time is not calculated.
traincard.calculate_interval(0)
new_time_to_show = traincard.time_to_show
time_deleta_in_seconds = (new_time_to_show - now).seconds
time_deleta_in_minutes = time_deleta_in_seconds / 60
self.assertEqual(time_deleta_in_minutes, 1428)
# Answer correct.
traincard.calculate_interval(5)
new_time_to_show = traincard.time_to_show
time_deleta_in_seconds = (new_time_to_show - now).seconds
time_deleta_in_minutes = time_deleta_in_seconds / 60
self.assertEqual(time_deleta_in_minutes, 24)
# Answer correct.
traincard.calculate_interval(5)
new_time_to_show = traincard.time_to_show
time_deleta_in_seconds = (new_time_to_show - now).seconds
time_deleta_in_minutes = time_deleta_in_seconds / 60
self.assertEqual(time_deleta_in_minutes, 144)
# Answer correct.
traincard.calculate_interval(5)
new_time_to_show = traincard.time_to_show
time_deleta_in_seconds = (new_time_to_show - now).seconds
time_deleta_in_minutes = time_deleta_in_seconds / 60
self.assertEqual(time_deleta_in_minutes, 504)
# Answer correct.
traincard.calculate_interval(5)
new_time_to_show = traincard.time_to_show
time_deleta_in_seconds = ((new_time_to_show - now).seconds +
(new_time_to_show - now).days * 24 * 60 * 60)
time_deleta_in_minutes = time_deleta_in_seconds / 60
self.assertEqual(time_deleta_in_minutes, 1814)
def test_check_the_train_nothing_to_train_link(self):
"""If the time to show for each card is still pending then nothing
to train should be shown near deck name on shelf page.
If deck wasn't ever started and training pool was not created for
deck then train link is present.
If there is at least one card to train then train link should be
shown there. If session is started
but not finished then continue session link should be shown there."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "What is it?"
card_answer = "This is that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
deck = Deck.objects.all()[0]
# Start shelf.
self.client.get("/user/shelf/%s/start/" % shelf.id)
# There are yet no cards in deck.
r = self.client.get("/user/shelf/%s/show/" % shelf.id)
self.assertIn("Train", r.content)
self.assertIn("(0)", r.content)
# Train the deck. There are no cards to train
# so session is not created.
self.client.get("/user/deck/%s/train/" % deck.id)
# Look on shelf page - training pool was created but there are no
# training cards so there is nothing to train.
r = self.client.get("/user/shelf/%s/show/" % shelf.id)
self.assertIn("Nothing to train", r.content)
self.assertIn("(0 / 0)", r.content)
# On deck page there are still no train cards to learn.
r = self.client.get("/user/deck/%s/show/" % deck.id)
self.assertNotIn("now", r.content)
# Add some card.
add_card(self.client, deck.id, card_question, card_answer)
# Now there is one card to learn which can be learnt "now".
r = self.client.get("/user/deck/%s/show/" % deck.id)
self.assertIn("now", r.content)
self.assertNotIn("from now", r.content)
# On shelf page there is also shown that one from one card can be
# learned.
r = self.client.get("/user/shelf/%s/show/" % shelf.id)
self.assertIn("Train", r.content)
self.assertIn("(1 / 1)", r.content)
# Answer wrong on this card.
self.client.get("/user/deck/%s/train/" % deck.id)
trainsessions = TrainSession.objects.all()
session = trainsessions[0]
self.client.post("/user/train/session/%s/" % session.id,
{"Answer": "Bad"})
# This card can be still learned because the answer was wrong.
r = self.client.get("/user/deck/%s/show/" % deck.id)
self.assertIn("now", r.content)
self.assertNotIn("from now", r.content)
# Also the same is shown on shelf page.
r = self.client.get("/user/shelf/%s/show/" % shelf.id)
self.assertIn("Train", r.content)
self.assertIn("(1 / 1)", r.content)
# Now answer right on this question.
self.client.get("/user/deck/%s/train/" % deck.id)
trainsessions = TrainSession.objects.all()
session = trainsessions[0]
self.client.post("/user/train/session/%s/" % session.id,
{"Answer": "Good"})
# New time to show was calculated for this card.
r = self.client.get("/user/deck/%s/show/" % deck.id)
self.assertIn("23 minutes from now", r.content)
# And there are currently no cards to learn.
r = self.client.get("/user/shelf/%s/show/" % shelf.id)
self.assertIn("Nothing to train", r.content)
self.assertIn("(0 / 1)", r.content)
def test_add_delete_new_cards_and_it_is_also_updated_in_train_pool(self):
"""If new cards are added to deck then it should be also
updated in train pool. If some card is deleted then train card
should be deleted too."""
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question1 = "What is it?"
card_answer1 = "This is that."
card_question2 = "What was it?"
card_answer2 = "This was that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# Add two cards.
deck = Deck.objects.all()[0]
# Start shelf.
self.client.get("/user/shelf/%s/start/" % shelf.id)
# No train pools are present before starting training.
trainpools = TrainPool.objects.all()
self.assertEqual(len(trainpools), 0)
# No train cards are present if there are no train pools.
traincards = TrainCard.objects.all()
self.assertEqual(len(traincards), 0)
# Train a new deck.
self.client.get("/user/deck/%s/train/" % deck.id)
# Training was started so train pool was created.
trainpools = TrainPool.objects.all()
self.assertEqual(len(trainpools), 1)
# But there are no cards so no train cards will be created.
traincards = TrainCard.objects.all()
self.assertEqual(len(traincards), 0)
# Add new card.
add_card(self.client, deck.id, card_question1, card_answer1)
# There is still one train pool.
trainpools = TrainPool.objects.all()
self.assertEqual(len(trainpools), 1)
# But when new card was added then new train card for this pool
# was also created.
traincards = TrainCard.objects.all()
self.assertEqual(len(traincards), 1)
# Add another card.
add_card(self.client, deck.id, card_question2, card_answer2)
# There is still one train pool.
trainpools = TrainPool.objects.all()
self.assertEqual(len(trainpools), 1)
# But the second card triggered also creation of new train card.
traincards = TrainCard.objects.all()
self.assertEqual(len(traincards), 2)
# Delete one card.
cards = Card.objects.all()
card = cards[0]
self.client.get("/card/%s/delete/" % card.id)
# There is still one train pool.
trainpools = TrainPool.objects.all()
self.assertEqual(len(trainpools), 1)
# The train card was also deleted when card was deleted.
traincards = TrainCard.objects.all()
self.assertEqual(len(traincards), 1)
def test_start_training(self):
shelf_name = "Some nice shelf"
deck_name = "Some nice deck"
card_question = "What is it?"
card_answer = "This is that."
add_shelf(self.client, shelf_name)
# Add deck.
shelf = Shelf.objects.all()[0]
add_deck(self.client, shelf.id, deck_name)
# Add card.
deck = Deck.objects.all()[0]
add_card(self.client, deck.id, card_question, card_answer)
# Start shelf.
self.client.get("/user/shelf/%s/start/" % shelf.id)
# Train a new deck.
r = self.client.get("/user/deck/%s/train/" % deck.id)
self.assertEqual(r.status_code, HttpResponseRedirect.status_code)
# One training session is present.
trainsessions = TrainSession.objects.all()
session = trainsessions[0]
self.assertEqual(len(trainsessions), 1)
# One training pool was created.
trainpools = TrainPool.objects.all()
self.assertEqual(len(trainpools), 1)
# One train card was created from existing cards.
traincards = TrainCard.objects.all()
self.assertEqual(len(traincards), 1)
# Check first question.
r = self.client.get("/user/train/session/%s/" % session.id)
self.assertIn(card_question, r.content)
# There are no more questions, so training session is finished
# and user is redirected to shelf page.
r = self.client.post("/user/train/session/%s/" % session.id,
{"Answer": "Good"})
self.assertIn("user/shelf/%s/show/" % shelf.id, r.get("location"))
# There are no training sessions now.
trainsessions = TrainSession.objects.all()
self.assertEqual(len(trainsessions), 0)
# But training pool is still present.
trainpools = TrainPool.objects.all()
self.assertEqual(len(trainpools), 1)
# The training cards was also not deleted.
traincards = TrainCard.objects.all()
self.assertEqual(len(traincards), 1)
# Stop shelf.
self.client.get("/user/shelf/%s/stop/" % shelf.id)
# But training pool is still present.
trainpools = TrainPool.objects.all()
self.assertEqual(len(trainpools), 0)
# The training cards was also not deleted.
traincards = TrainCard.objects.all()
self.assertEqual(len(traincards), 0)
