def test_add_song_existing_with_replace_exisiting_tags():
db_song = mixer.blend(
SongDb,
title="title",
albums=mixer.blend(AlbumDb, name="album"),
artists=mixer.blend(ArtistDb, name="artist"),
tags=mixer.blend(TagDb, tag_type="type", value="value"),
)
song = song_logic.add(
SongIn(
title="title",
length=1,
album="album2",
album_artist="artist2",
artist="artist",
tags=[TagIn(tag_type="type2", value="value2")],
),
return_existing=True,
update_existing=True,
replace_existing_tags=True,
)
db.flush()
assert db_song.id == song.id
assert len(song.albums) == 2
assert len(song.tags) == 1
assert orm.count(s for s in SongDb) == 1
assert orm.count(t for t in TagDb) == 2
assert orm.count(a for a in ArtistDb) == 2
assert orm.count(a for a in AlbumDb) == 2
def test_add_song_existing_add_length():
db_song = mixer.blend(
SongDb, length=None, title="title", artists=mixer.blend(ArtistDb, name="artist")
)
song = song_logic.add(
SongIn(title="title", artist="artist", length=250, album="album2"),
return_existing=True,
update_existing=True,
)
db.flush()
assert db_song.id == song.id
assert orm.count(s for s in SongDb) == 1
assert db_song.length == song.length
def test_add_song_existing_album():
album = mixer.blend(AlbumDb, album_artist=mixer.blend(ArtistDb))
song_logic.add(
SongIn(
title="title",
length=1,
album=album.name,
album_artist=album.album_artist.name,
artist="artist1",
tags=[TagIn(tag_type="type", value="tag")],
)
)
assert orm.count(s for s in SongDb) == 1
assert orm.count(t for t in TagDb) == 1
assert orm.count(a for a in ArtistDb) == 2
assert orm.count(a for a in AlbumDb) == 1
def test_get_song_multiple_artists():
db_song = mixer.blend(SongDb, artists=mixer.cycle(2).blend(ArtistDb))
artists = [a.name for a in db_song.artists]
song = song_logic.get(title=db_song.title, artists=artists)
assert song is not None
assert song.title == db_song.title
assert len(song.artists) == 2
def test_add_album_existing_with_new_album_artist():
db_album = mixer.blend(AlbumDb, album_artist=None)
assert not db_album.album_artist
album = album_logic.add(name=db_album.name,
artist="test",
return_existing=True)
assert orm.count(a for a in AlbumDb) == 1
assert album is not None
assert db_album.id == album.id
assert db_album.album_artist.name == "test"
def test_add_song_existing():
mixer.blend(
SongDb,
title="title",
albums=mixer.blend(AlbumDb, name="album"),
artists=mixer.blend(ArtistDb, name="artist"),
tags=mixer.blend(TagDb, tag_type="type", value="value"),
)
with pytest.raises(IntegrityError):
song_logic.add(
SongIn(
title="title",
length=1,
album="album",
album_artist="artist",
artist="artist",
tags=[TagIn(tag_type="type", value="value")],
)
)
def test_add_song_existing_with_return_existing_cleaned_artist():
db_song = mixer.blend(
SongDb,
title="title",
albums=mixer.blend(AlbumDb, name="album"),
artists=mixer.blend(ArtistDb, name="artist"),
tags=mixer.blend(TagDb, tag_type="type", value="value"),
)
song = song_logic.add(
SongIn(
title="title",
length=1,
album="album",
album_artist="artist",
artist="artist (cv. hallo)",
tags=[TagIn(tag_type="type", value="value")],
),
return_existing=True,
)
assert db_song.id == song.id
def test_add_song_existing_tag():
tag = mixer.blend(TagDb)
song_logic.add(
SongIn(
title="title",
length=1,
album="album",
album_artist="artist",
artist="artist1",
tags=[TagIn(tag_type=tag.tag_type, value=tag.value)],
)
)
assert orm.count(s for s in SongDb) == 1
assert orm.count(t for t in TagDb) == 1
assert orm.count(a for a in ArtistDb) == 2
assert orm.count(a for a in AlbumDb) == 1
def test_get_album_by_id_existing():
album_db = mixer.blend(AlbumDb)
orm.flush()
album = album_logic.get_by_id(id=album_db.id)
assert album is not None
def test_get_album_by_name_no_album_artist():
db_album = mixer.blend(AlbumDb)
album = album_logic.get_by_name(name=db_album.name)
assert album is not None
def test_add_album_existing_album_with_return_existing():
db_album = mixer.blend(AlbumDb)
album = album_logic.add(name=db_album.name, return_existing=True)
assert orm.count(a for a in AlbumDb) == 1
assert album is not None
assert db_album.id == album.id
def test_add_album_existing_album():
album = mixer.blend(AlbumDb)
with pytest.raises(IntegrityError):
album_logic.add(name=album.name)
def test_get_tag_existing():
db_tag = mixer.blend(TagDb)
tag = tag_logic.get_by_values(tag_type=db_tag.tag_type, value=db_tag.value)
assert tag is not None
assert tag.tag_type == db_tag.tag_type
assert tag.value == db_tag.value
def test_get_artist_by_name_existing_reversed():
db_artist = mixer.blend(ArtistDb, name="first second")
artist = artist_logic.get_by_name(name="second first")
assert artist is not None
assert db_artist.name == artist.name
def test_get_artist_by_name_cleaned_name():
db_artist = mixer.blend(ArtistDb, name="test")
artist = artist_logic.get_by_name(name="test (cv. test1)")
assert artist is not None
assert db_artist.name == artist.name
def test_album_exists_existing():
db_album = mixer.blend(AlbumDb)
exists = album_logic.exists(name=db_album.name)
assert exists
def test_add_album_existing_artist():
artist = mixer.blend(ArtistDb)
album_logic.add(name="album", artist=artist.name)
assert orm.count(a for a in AlbumDb) == 1
assert orm.count(a for a in ArtistDb) == 1
def test_get_artist_by_id_existing():
db_artist = mixer.blend(ArtistDb)
orm.flush()
artist = artist_logic.get_by_id(id=db_artist.id)
assert artist is not None
assert db_artist.name == artist.name
def test_get_tag_existing_case_difference():
db_tag = mixer.blend(TagDb, tag_type="Type", value="Value")
tag = tag_logic.get_by_values(tag_type="type", value="value")
assert tag is None
def test_artist_exists_existing():
db_artist = mixer.blend(ArtistDb)
exists = artist_logic.exists(db_artist.name)
assert exists
