def test_prepare_db_objects_recreates_existing_track(mocker):
from cozy.model.database_importer import DatabaseImporter
from cozy.media.media_file import MediaFile
from cozy.media.chapter import Chapter
from cozy.db.track_to_file import TrackToFile
from cozy.db.file import File
database_importer = DatabaseImporter()
chapter = Chapter("New Chapter", 0, 1234567, 999)
media_file = MediaFile(book_name="Test Book",
author="New Author",
reader="New Reader",
disk=999,
cover=b"cover",
path="test.mp3",
modified=1234567,
chapters=[chapter])
res = database_importer._prepare_track_db_objects([media_file])
res_list = list(res)
request = res_list[0]
assert TrackToFile.select().join(File).where(
File.path == "test.mp3").count() == 0
assert len(res_list) == 1
assert request.file.path == "test.mp3"
assert request.start_at == 0
assert request.track_data["name"] == "New Chapter"
assert request.track_data["number"] == 999
assert request.track_data["disk"] == 999
assert request.track_data["book"].id == 1
assert request.track_data["length"] == 1234567
assert request.track_data["position"] == 0
def test_create_book_db_object_creates_object():
from cozy.model.database_importer import DatabaseImporter
from cozy.media.media_file import MediaFile
from cozy.db.book import Book
from cozy.media.chapter import Chapter
database_importer = DatabaseImporter()
chapter = Chapter("New Chapter", 0, 1234567, 999)
media_file = MediaFile(book_name="New Book",
author="New Author",
reader="New Reader",
disk=999,
cover=b"cover",
path="test.mp3",
modified=1234567,
chapters=[chapter])
database_importer._create_book_db_object(media_file)
book_in_db: Book = Book.select().where(Book.name == "New Book").get()
assert book_in_db.name == "New Book"
assert book_in_db.author == "New Author"
assert book_in_db.reader == "New Reader"
assert book_in_db.cover == b"cover"
assert book_in_db.position == 0
assert book_in_db.rating == -1
def test_create_track_db_object_creates_object():
from cozy.model.library import Library
from cozy.media.media_file import MediaFile
from cozy.db.book import Book
from cozy.media.chapter import Chapter
library = Library()
chapter = Chapter("New Chapter", 0)
media_file = MediaFile(book_name="New Book Name",
author="New Author",
reader="New Reader",
disk=999,
track_number=999,
length=1234567,
cover=b"cover",
path="New File",
modified=1234567,
chapters=[chapter])
book = Book.select().get()
res_dict = library._get_track_dictionary_for_db(media_file, book)
assert res_dict["name"] == "New Chapter"
assert res_dict["disk"] == 999
assert res_dict["number"] == 999
assert res_dict["book"] == book
assert res_dict["file"] == "New File"
assert res_dict["length"] == 1234567
assert res_dict["modified"] == 1234567
assert res_dict["position"] == 0
def test_create_track_db_object_creates_object():
from cozy.model.database_importer import DatabaseImporter
from cozy.media.media_file import MediaFile
from cozy.db.book import Book
from cozy.media.chapter import Chapter
database_importer = DatabaseImporter()
chapter = Chapter("New Chapter", 0, 1234567, 999)
media_file = MediaFile(book_name="New Book Name",
author="New Author",
reader="New Reader",
disk=999,
cover=b"cover",
path="New File",
modified=1234567,
chapters=[chapter])
book = Book.select().get()
res_dict = database_importer._get_track_list_for_db(media_file, book)[0]
assert res_dict["name"] == "New Chapter"
assert res_dict["disk"] == 999
assert res_dict["number"] == 999
assert res_dict["book"] == book
assert res_dict["length"] == 1234567
assert res_dict["position"] == 0
def test_create_book_db_object_creates_object():
from cozy.model.library import Library
from cozy.media.media_file import MediaFile
from cozy.db.book import Book
from cozy.media.chapter import Chapter
library = Library()
chapter = Chapter("New Chapter", 0)
media_file = MediaFile(book_name="New Book",
author="New Author",
reader="New Reader",
disk=999,
track_number=999,
length=1234567,
cover=b"cover",
path="test.mp3",
modified=1234567,
chapters=[chapter])
library._create_book_db_object(media_file)
book_in_db: Book = Book.select().where(Book.name == "New Book").get()
assert book_in_db.name == "New Book"
assert book_in_db.author == "New Author"
assert book_in_db.reader == "New Reader"
assert book_in_db.cover == b"cover"
assert book_in_db.position == 0
assert book_in_db.rating == -1
def test_update_track_db_object_updates_object():
from cozy.model.library import Library
from cozy.media.media_file import MediaFile
from cozy.db.book import Book
from cozy.media.chapter import Chapter
from cozy.db.track import Track
library = Library()
chapter = Chapter("New Chapter", 0)
media_file = MediaFile(book_name="New Book Name",
author="New Author",
reader="New Reader",
disk=999,
track_number=999,
length=1234567,
cover=b"cover",
path="test.mp3",
modified=1234567,
chapters=[chapter])
book = Book.select().get()
library._update_track_db_object(media_file, book)
track_in_db: Track = Track.select().where(Track.file == "test.mp3").get()
assert track_in_db.name == "New Chapter"
assert track_in_db.disk == 999
assert track_in_db.number == 999
assert track_in_db.length == 1234567
assert track_in_db.modified == 1234567
def test_delete_all_tracks_from_db_does_as_it_says():
from cozy.media.media_file import MediaFile
from cozy.media.chapter import Chapter
from cozy.db.file import File
from cozy.db.track import Track
from cozy.db.track_to_file import TrackToFile
from cozy.model.database_importer import DatabaseImporter
database_importer = DatabaseImporter()
chapter = Chapter("Ohne Aussicht auf Freiheit", 0, 1234567, 999)
media_file = MediaFile(
book_name="Test Book New",
author="New Author2",
reader="New Reader",
disk=999,
cover=b"cover",
path="20.000 Meilen unter dem Meer/2-10 Ohne Aussicht auf Freiheit.m4a",
modified=1234567,
chapters=[chapter])
assert Track.select().where(
Track.name == "Ohne Aussicht auf Freiheit").count() == 1
assert TrackToFile.select().join(File).where(
TrackToFile.file.path == media_file.path).count() == 1
database_importer._delete_tracks_from_db(media_file)
assert Track.select().where(
Track.name == "Ohne Aussicht auf Freiheit").count() == 0
assert TrackToFile.select().join(File).where(
TrackToFile.file.path == media_file.path).count() == 0
assert File.select().where(File.path == media_file.path).count() == 1
def get_tags(self) -> MediaFile:
media_file = MediaFile(path=unquote(urlparse(self.uri).path),
book_name=self._get_book_name(),
author=self._get_author(),
reader=self._get_reader(),
disk=self._get_disk(),
chapters=self._get_chapters(),
cover=self._get_cover(),
modified=self._get_modified())
return media_file
def test_execute_import_returns_list_of_imported_files(mocker):
from cozy.media.importer import Importer
media_file1 = MediaFile(book_name="a",
author="a",
reader="a",
disk=1,
track_number=1,
length=1,
cover=b"",
path="path",
modified=1,
chapters=[])
media_file2 = MediaFile(book_name="a",
author="a",
reader="a",
disk=1,
track_number=1,
length=1,
cover=b"",
path="path2",
modified=1,
chapters=[])
class Mock:
def get(self):
return self.iterator()
def iterator(self):
for item in [media_file1, media_file2, None]:
yield item
mocker.patch("multiprocessing.pool.Pool.map_async", return_value=Mock())
mocker.patch("cozy.media.importer.Importer._wait_for_job_to_complete")
mocker.patch("cozy.model.library.Library.insert_many")
importer = Importer()
imported, _ = importer._execute_import(["a", "b"])
assert all([a == b for a, b in zip(imported, ["path", "path2"])])
def test_prepare_db_objects_updates_existing_book_regardless_of_spelling(
mocker):
from cozy.model.database_importer import DatabaseImporter
from cozy.media.media_file import MediaFile
from cozy.media.chapter import Chapter
from cozy.db.file import File
database_importer = DatabaseImporter()
spy = mocker.spy(database_importer, "_update_book_db_object")
File.create(path="New test File", modified=1234567)
File.create(path="Another test File", modified=1234568)
chapter = Chapter("New Chapter", 0, 1234567, 999)
another_chapter = Chapter("Another Chapter", 0, 1234567, 999)
media_file = MediaFile(book_name="TeSt bOOk",
author="New Author2",
reader="New Reader",
disk=999,
cover=b"cover",
path="New test File",
modified=1234567,
chapters=[chapter])
another_media_file = MediaFile(book_name="TEST BOOK",
author="New Author2",
reader="New Reader",
disk=999,
cover=b"cover",
path="Another test File",
modified=1234568,
chapters=[another_chapter])
res_dict = database_importer._prepare_track_db_objects(
[media_file, another_media_file])
assert len(list(res_dict)) == 2
spy.assert_called_once()
def test_prepare_files_db_objects_skips_existing_files():
from cozy.model.database_importer import DatabaseImporter
from cozy.media.media_file import MediaFile
media_file = MediaFile(book_name="New Book Name",
author="New Author",
reader="New Reader",
disk=999,
cover=b"cover",
path="test.mp3",
modified=1234567,
chapters=[None])
database_importer = DatabaseImporter()
file_objects = database_importer._prepare_files_db_objects([media_file])
assert len(file_objects) == 0
def test_is_chapter_count_in_db_different_returns_true_for_non_existent_file():
from cozy.media.media_file import MediaFile
from cozy.model.database_importer import DatabaseImporter
database_importer = DatabaseImporter()
media_file = MediaFile(book_name="Test Book New",
author="New Author2",
reader="New Reader",
disk=999,
cover=b"cover",
path="file_not_present",
modified=1234567,
chapters=["Chapter 1"])
assert database_importer._is_chapter_count_in_db_different(media_file)
def test_delete_all_tracks_from_db_does_nothing_if_no_tracks_are_present():
from cozy.media.media_file import MediaFile
from cozy.model.database_importer import DatabaseImporter
database_importer = DatabaseImporter()
media_file = MediaFile(book_name="Test Book New",
author="New Author2",
reader="New Reader",
disk=999,
cover=b"cover",
path="file_not_present",
modified=1234567,
chapters=[])
database_importer._delete_tracks_from_db(media_file)
def test_prepare_files_db_objects_returns_object_for_new_file():
from cozy.model.database_importer import DatabaseImporter
from cozy.media.media_file import MediaFile
media_file = MediaFile(book_name="New Book Name",
author="New Author",
reader="New Reader",
disk=999,
cover=b"cover",
path="i_m_a_new_file.mp3",
modified=1234567,
chapters=[None])
database_importer = DatabaseImporter()
file_objects = database_importer._prepare_files_db_objects([media_file])
assert len(file_objects) == 1
assert file_objects[0]["path"] == "i_m_a_new_file.mp3"
def test_is_chapter_count_in_db_different_returns_false_for_equal_chapter_count(
):
from cozy.media.media_file import MediaFile
from cozy.model.database_importer import DatabaseImporter
database_importer = DatabaseImporter()
media_file = MediaFile(
book_name="Test Book New",
author="New Author2",
reader="New Reader",
disk=999,
cover=b"cover",
path="20.000 Meilen unter dem Meer/2-10 Ohne Aussicht auf Freiheit.m4a",
modified=1234567,
chapters=[None])
assert not database_importer._is_chapter_count_in_db_different(media_file)
def test_update_files_db_objects_updates_modified_field():
from cozy.model.database_importer import DatabaseImporter
from cozy.media.media_file import MediaFile
from cozy.db.file import File
media_file = MediaFile(book_name="New Book Name",
author="New Author",
reader="New Reader",
disk=999,
cover=b"cover",
path="test.mp3",
modified=12345678,
chapters=[None])
database_importer = DatabaseImporter()
file = File.select().where(File.path == "test.mp3").get()
file_objects = database_importer._update_files_in_db(file, media_file)
assert File.select().where(
File.path == "test.mp3").get().modified == 12345678
def test_prepare_db_objects_skips_if_file_object_not_present(mocker):
from cozy.model.database_importer import DatabaseImporter
from cozy.media.media_file import MediaFile
from cozy.media.chapter import Chapter
database_importer = DatabaseImporter()
chapter = Chapter("New Chapter", 0, 1234567, 999)
media_file = MediaFile(book_name="Test Book",
author="New Author",
reader="New Reader",
disk=999,
cover=b"cover",
path="New test File",
modified=1234567,
chapters=[chapter])
res_dict = database_importer._prepare_track_db_objects([media_file])
assert len(list(res_dict)) == 0
def test_prepare_db_objects_raises_not_implemented_for_multi_chapter_file(mocker):
from cozy.model.library import Library
from cozy.media.media_file import MediaFile
from cozy.media.chapter import Chapter
library = Library()
chapter = Chapter("New Chapter", 0)
media_file = MediaFile(book_name="Test Book New",
author="New Author2",
reader="New Reader",
disk=999,
track_number=999,
length=1234567,
cover=b"cover",
path="New test File",
modified=1234567,
chapters=[chapter, chapter])
with pytest.raises(NotImplementedError):
res_dict = library._prepare_db_objects([media_file])
list(res_dict)
def test_prepare_db_objects_creates_new_book(mocker):
from cozy.model.library import Library
from cozy.media.media_file import MediaFile
from cozy.media.chapter import Chapter
library = Library()
spy = mocker.spy(library, "_create_book_db_object")
chapter = Chapter("New Chapter", 0)
media_file = MediaFile(book_name="Test Book New",
author="New Author2",
reader="New Reader",
disk=999,
track_number=999,
length=1234567,
cover=b"cover",
path="New test File",
modified=1234567,
chapters=[chapter])
res_dict = library._prepare_db_objects([media_file])
assert len(list(res_dict)) == 1
spy.assert_called_once()
def test_prepare_db_objects_creates_new_book(mocker):
from cozy.model.database_importer import DatabaseImporter
from cozy.media.media_file import MediaFile
from cozy.media.chapter import Chapter
from cozy.db.file import File
database_importer = DatabaseImporter()
spy = mocker.spy(database_importer, "_create_book_db_object")
File.create(path="New test File", modified=1234567)
chapter = Chapter("New Chapter", 0, 1234567, 999)
media_file = MediaFile(book_name="Test Book New",
author="New Author2",
reader="New Reader",
disk=999,
cover=b"cover",
path="New test File",
modified=1234567,
chapters=[chapter])
res_dict = database_importer._prepare_track_db_objects([media_file])
assert len(list(res_dict)) == 1
spy.assert_called_once()