def test_save_learning_state():
# This file will be empty
fake_file = mock_open(read_data='{}')
# Function open returns fake_file
flexmock(builtins, open=fake_file)
# MyVocabulary and LearningState is not saved
flexmock(MyVocabulary, save_my_vocabulary=lambda: None)
my_vocabulary = MyVocabulary()
# Setting my_vocabulary.chosen_words
my_vocabulary.chosen_words = {"koupit": "buy"}
flexmock(LearningState, __del__=lambda: None)
# Setting learning_state with my_vocabulary.chosen_words
learning_state = LearningState(my_vocabulary)
learning_state.save_learning_state()
string = ''
for call in fake_file.return_value.write.mock_calls:
string += (call[1][0])
assert string == '{"round_mistakes": 0,' \
' "successful": 0,' \
' "unsuccessful": 0,' \
' "ordered_words": ["koupit"],' \
' "words": {' \
'"koupit": {"value": "buy", "learned": false,' \
' "round_mistakes": 0, "total_mistakes": 0}}}\n'
def test_check_guessing_successfully(offered_word, answered_word):
__mock()
my_vocabulary = MyVocabulary()
my_vocabulary.chosen_words = {
"koupit": "buy",
"být": "be",
"postavit": "build"
}
learning_process = LearningProcess(LearningState(my_vocabulary))
assert learning_process.check_guessing(offered_word, answered_word)
def test_check_guessing_unsuccessfully(offered_word, answered_word):
__mock()
my_vocabulary = MyVocabulary()
my_vocabulary.chosen_words = {
"koupit": "buy",
"být": "be",
"postavit": "build"
}
flexmock(LearningState, __del__=lambda: None)
learning_process = LearningProcess(LearningState(my_vocabulary))
assert not learning_process.check_guessing(offered_word, answered_word)
def test_get_value(key, value):
__mock()
my_vocabulary = MyVocabulary()
my_vocabulary.chosen_words = {
"koupit": "buy",
"být": "be",
"postavit": "build"
}
learning_state = LearningState(my_vocabulary)
learning_state.reset_learning_state()
assert learning_state.get_value(key) == value
def test_fail_counters(key):
__mock()
my_vocabulary = MyVocabulary()
my_vocabulary.chosen_words = {
"koupit": "buy",
"být": "be",
"postavit": "build"
}
learning_state = LearningState(my_vocabulary)
total_m = learning_state.words[key]['total_mistakes']
unsuccessful = learning_state.unsuccessful
round_m = learning_state.round_mistakes
learning_process = LearningProcess(learning_state)
learning_process.increment_fail_counters(key)
assert learning_state.words[key]['total_mistakes'] == total_m + 1
assert learning_state.round_mistakes == round_m + 1
assert learning_state.unsuccessful == unsuccessful + 1
def __init__(self, request):
super().__init__(request)
self.message = None
self.offered_word = None
self.answered_word = None
self.is_done = False
self.result = None
self.successful = 0
self.unsuccessful = 0
self.my_vocabulary = MyVocabulary()
self.learning_state = LearningState(self.my_vocabulary)
self.learning_process = LearningProcess(self.learning_state)
class AdminController(BaseController):
"""
Class for administration of MY VOCABULARY (entering or deleting words).
After each statement my vocabulary is saved.
Instance attributes:
* self.my_vocabulary: instance of the class MyVocabulary
* self.message: message above input type text
* self.message_mv: message above table of MY VOCABULARY
"""
def __init__(self, request):
super().__init__(request)
self.my_vocabulary = MyVocabulary()
self.message = None
self.message_mv = None
def process_add(self):
"""
Processes what should happen when the user presses "add"
(successful deletion and various situations of unsuccessful
deletion).
:return: None
"""
required_word = self.get_required_word('word')
# Nothing was entered
if not required_word:
self.message = "Enter some word."
# Not in used dictionary
elif not self.my_vocabulary.word_is_in_dictionary(required_word):
self.message = "This word is not in used dictionary. " \
"Try adding another word."
# Already in my vocabulary
elif self.my_vocabulary.word_is_in_mv(required_word):
self.message = "This word has been already added. " \
"Try adding another word."
else:
# Successful addition
self.my_vocabulary.add_word(required_word)
self.message = "The word has been successfully added."
def process_delete_word(self):
"""
Processes what should happen when the user presses "delete"
(successfully deletion and various situations of unsuccessfully
deletion).
:return: None
"""
required_word = self.get_required_word('word')
# Nothing was entered
if not required_word:
self.message = "Enter some word."
# Not in my_vocabulary.chosen_words
elif not self.my_vocabulary.word_is_in_mv(required_word):
self.message = "This word is not in MY VOCABULARY. " \
"Try deleting another word."
else:
# Successful deletion
self.my_vocabulary.delete_word(required_word)
self.message = "This word has been successfully deleted."
def process_delete_words(self):
"""
Processes what should happen when the user presses "delete_words"
(successful deletion and various situations of unsuccessful
deletion).
:return: None
"""
required_words = self.get_required_words()
# Nothing was selected
if not required_words:
self.message_mv = "There are no selected words to delete."
else:
# Successfully deletion
deleted = self.my_vocabulary.delete_words(required_words)
self.message_mv = f"Number of successfully deleted words:" \
f" {deleted}"
def handle_admin_controller(self):
"""
Handles administration of MY VOCABULARY.
:return: None
"""
# The user pressed "Add word"
if self.is_in_args('add'):
self.process_add()
# "Delete" submit button was pressed
elif self.is_in_args('delete'):
self.process_delete_word()
# Some words were selected and submit button "Delete" was pressed
elif self.is_in_args('delete_words'):
self.process_delete_words()
# No words in MY VOCABULARY
if not self.message and not self.my_vocabulary.chosen_words:
self.message = "MY VOCABULARY is empty. Enter some words."
def prepare_render_template(self):
"""
Returns render_template for admin_page.
:return: str
"""
return render_template('administration.html',
message=self.message,
message_mv=self.message_mv,
chosen_words=self.my_vocabulary.chosen_words)
def __init__(self, request):
super().__init__(request)
self.my_vocabulary = MyVocabulary()
self.message = None
self.message_mv = None
def __prepare():
return LearningState(MyVocabulary())
def __prepare():
return MyVocabulary()
def test_create_mv():
flexmock(builtins).should_receive('open').and_raise(FileNotFoundError)
faked_vocabulary = MyVocabulary()
assert faked_vocabulary.chosen_words == {}