def test_get_known_words(self):
words_list_comparator = ContainerComparator(
elem_equality_comparator=lambda lhs, rhs: lhs == rhs,
sort_key=lambda w: w)
database = Database(self.db_handle)
self.assertEqual(len(database.get_known_words()), 0)
book1 = Book.from_path(f"{base_dir}/test/data/book.epub")
for word in book1.words:
word.mark_if_known(True)
book2 = Book.from_path(f"{base_dir}/test/data/book2.epub")
for word in book2.words:
word.mark_if_known(True)
database.store_book(book1)
database.store_book(book2)
book1_raw_known_words = set(w.stored_word for w in book1.known_words)
book2_raw_known_words = set(w.stored_word for w in book2.known_words)
both_books_words = book1_raw_known_words.union(book2_raw_known_words)
self.assertTrue(
words_list_comparator(database.get_known_words(),
both_books_words))
def test_storing_and_restoring_book(self):
database = Database(self.db_handle)
book = Book.from_path(f"{base_dir}/test/data/book.epub")
# small data manipulation to make sure that it was retained when saving to db
for word in book.words:
word.mark_if_known(True)
database.store_book(book)
restored_book = database.restore_book(book.name)
words_list_comparator = ContainerComparator(
elem_equality_comparator=self._are_words_equal,
sort_key=lambda w: w.stored_word)
self.assertEqual(book.are_all_words_processed(),
restored_book.are_all_words_processed())
self.assertTrue(
words_list_comparator(book.known_words, restored_book.known_words))
self.assertTrue(
words_list_comparator(book.unknown_words,
restored_book.unknown_words))
self.assertEqual(book.name, restored_book.name)
self.assertTrue(words_list_comparator(book.words, restored_book.words))
self.assertEqual(book.flashcards, restored_book.flashcards)
def test_something(self):
feature = MakeFlashcards()
interface = Interface()
book = Book.from_path(f"{base_dir}\\test\\data\\short_book.epub")
for word in book.words:
word.mark_if_known(False)
feature.run(interface, book)
def run(self, interface, **kwargs):
book_path = interface.get_input("Enter path to ebook",
input_processor=FilePathProcessor())
book = Book.from_path(book_path)
db = Database()
db.store_book(book)
return book
def test_are_all_words_processed(self):
data_dir = f"{base_dir}\\test\\data\\"
file_name = "book.epub"
book = Book.from_path(data_dir + file_name)
self.assertFalse(book.are_all_words_processed())
for word in book.words:
word.mark_if_known(True)
self.assertTrue(book.are_all_words_processed())
def test_creation_from_file(self):
data_dir = f"{base_dir}\\test\\data\\"
file_name = "book.epub"
book = Book.from_path(data_dir + file_name)
self.assertEqual(len(book.known_words), 0)
self.assertEqual(len(book.unknown_words), 0)
self.assertEqual(len(book.flashcards), 0)
self.assertEqual(len(book.words), 6349)
self.assertEqual(book.name, file_name)
self.assertEqual(book.path, data_dir+file_name)
def test_known_and_unknown_words_getters(self):
data_dir = f"{base_dir}\\test\\data\\"
file_name = "book.epub"
book = Book.from_path(data_dir + file_name)
self.assertEqual(len(book.known_words), 0)
self.assertEqual(len(book.unknown_words), 0)
known_words_to_mark = {"the", "it", "on"}
for word in book.words:
if word.stored_word in known_words_to_mark:
word.mark_if_known(True)
self.assertEqual({w.stored_word for w in book.known_words}, known_words_to_mark)
unknown_words_to_mark = {"she", "he"}
for word in book.words:
if word.stored_word in unknown_words_to_mark:
word.mark_if_known(False)
self.assertEqual({w.stored_word for w in book.unknown_words}, unknown_words_to_mark)
def test_has_book(self):
database = Database(self.db_handle)
book_dir = f"{base_dir}/test/data/book.epub"
book = Book.from_path(book_dir)
database.store_book(book)
self.assertTrue(database.has_book(book.name))
