def test_search_filter_artists(factory: Factory, db: Connection):
art1 = factory.artist(conn=db)
art2 = factory.artist(conn=db)
# Create some releases only on one artist.
factory.release(artists=[{
"artist_id": art1.id,
"role": ArtistRole.MAIN
}],
conn=db)
factory.release(artists=[{
"artist_id": art2.id,
"role": ArtistRole.MAIN
}],
conn=db)
# Now create some for both; these are what we want to see in search results.
releases = [
factory.release(
artists=[
{
"artist_id": art1.id,
"role": ArtistRole.MAIN
},
{
"artist_id": art2.id,
"role": ArtistRole.MAIN
},
],
conn=db,
) for _ in range(5)
]
out = release.search(db, artist_ids=[art1.id, art2.id])
assert set(releases) == set(out)
def test_count_one(factory: Factory, db: Connection):
factory.release(title="We Will Always Have Seventy Children", conn=db)
for _ in range(5):
factory.release(conn=db)
count = release.count(db, search="Have Seventy Will Children")
assert count == 1
def test_search_filter_year(factory: Factory, db: Connection):
factory.release(release_year=None, conn=db)
factory.release(release_year=2000, conn=db)
rls = factory.release(release_year=2014, conn=db)
releases = release.search(db, years=[2014])
assert releases == [rls]
def test_count_all(factory: Factory, db: Connection):
for _ in range(5):
factory.release(conn=db)
count = release.count(db)
# One extra for Unknown Release.
assert count == 5 + 1
def test_all_years(factory: Factory, db: Connection):
factory.release(release_year=2016, conn=db)
factory.release(release_year=2014, conn=db)
factory.release(release_year=None, conn=db)
years = release.all_years(db)
assert set(years) == {2016, 2014}
def test_search_sort_random(factory: Factory, db: Connection):
for _ in range(5):
factory.release(conn=db)
# Make sure it returns **something**.
results = release.search(sort=ReleaseSort.RANDOM, asc=True, conn=db)
assert len(results) > 0
def test_search_sort_title(factory: Factory, db: Connection):
for _ in range(5):
factory.release(conn=db)
out = release.search(sort=ReleaseSort.TITLE, asc=True, conn=db)
titles = [rls.title for rls in out]
assert titles == sorted(titles, key=str.casefold)
def test_search_asc(factory: Factory, db: Connection):
for _ in range(5):
factory.release(conn=db)
asc_true = release.search(sort=ReleaseSort.TITLE, asc=True, conn=db)
asc_false = release.search(sort=ReleaseSort.TITLE, asc=False, conn=db)
assert asc_true == asc_false[::-1]
def test_search_filter_rating(factory: Factory, db: Connection):
factory.release(rating=2, conn=db)
factory.release(rating=None, conn=db)
rls1 = factory.release(rating=4, conn=db)
rls2 = factory.release(rating=6, conn=db)
releases = release.search(db, ratings=[6, 4])
assert {rls1, rls2} == set(releases)
def test_search_page(factory: Factory, db: Connection):
for _ in range(5):
factory.release(conn=db)
out1 = release.search(page=1, per_page=2, conn=db)
out2 = release.search(page=2, per_page=2, conn=db)
assert len(out1) == 2
assert len(out2) == 2
assert out1 != out2
def test_populate_inbox(factory: Factory, db: Connection):
usr, _ = user.create("neW1", db)
for _ in range(12):
factory.release(conn=db)
db.commit()
user._populate_inbox.call_local(usr.id)
inbox = collection.inbox_of(usr.id, conn=db)
assert len(collection.releases(inbox, conn=db)) == 12
def test_search_filter_release_type(factory: Factory, db: Connection):
# Create a release that we don't want to show up.
factory.release(release_type=ReleaseType.ALBUM, conn=db)
# Create the releases we want to get.
releases = [
factory.release(release_type=ReleaseType.EP, conn=db) for _ in range(5)
]
out = release.search(db, release_types=[ReleaseType.EP])
assert set(releases) == set(out)
def test_image(factory: Factory, db: Connection):
art = factory.artist(conn=db)
img = factory.mock_image(conn=db)
factory.release(
artists=[{"artist_id": art.id, "role": ArtistRole.MAIN}],
image_id=img.id,
conn=db,
)
new_img = artist.image(art, db)
assert new_img is not None
assert new_img.id == img.id
def test_search_sort_year(factory: Factory, db: Connection):
for _ in range(5):
factory.release(release_year=factory.rand_year(), conn=db)
releases = release.search(sort=ReleaseSort.YEAR, asc=True, conn=db)
# This is the Unknown Release (with a null year). Should be sorted last.
assert releases[-1].release_year is None
not_null_years = [rls.release_year for rls in releases[:-1]]
assert None not in not_null_years
assert not_null_years == sorted(not_null_years) # type: ignore
def test_catalog_file_duplicate_artist(
tagfile: mock.MagicMock,
calc_sha: mock.MagicMock,
mock_fetch_or_create_release: mock.MagicMock,
factory: Factory,
db: Connection,
):
filepath = "/tmp/music.m4a"
rls = factory.release(conn=db)
mock_fetch_or_create_release.return_value = mock.Mock(id=rls.id)
calc_sha.return_value = b"0" * 32
tagfile.return_value = mock.Mock(
artist={ArtistRole.MAIN: ["art1", "art1"]},
title=None,
version=None,
path=Path(filepath),
mut=mock.Mock(info=mock.Mock(length=1)),
track_number="1",
disc_number="1",
)
catalog_file(filepath, db)
trk = track.from_filepath(filepath, db)
assert trk is not None
assert len(track.artists(trk, db)) == 1
def test_add_release_failure(factory: Factory, db: Connection):
col = factory.collection(conn=db)
rls = factory.release(conn=db)
collection.add_release(col, rls.id, db)
with pytest.raises(AlreadyExists):
collection.add_release(col, rls.id, db)
def test_create_bad_artist_ids(factory: Factory, db: Connection):
art = factory.artist(conn=db)
rls = factory.release(conn=db)
with pytest.raises(NotFound) as e:
track.create(
title="new track",
filepath=Path("/tmp/repertoire-library/09-track.m4a"),
sha256_initial=b"0" * 32,
release_id=rls.id,
artists=[
{
"artist_id": art.id,
"role": ArtistRole.MAIN
},
{
"artist_id": 1000,
"role": ArtistRole.MAIN
},
{
"artist_id": 1001,
"role": ArtistRole.MAIN
},
],
duration=9001,
track_number="1",
disc_number="2",
conn=db,
)
assert e.value.message is not None
assert "Artist(s) 1000, 1001" in e.value.message
def test_create_same_album_name_artist_subset_no_duplicate_trigger(
factory: Factory,
db: Connection,
):
art1 = factory.artist(conn=db)
art2 = factory.artist(conn=db)
rls1 = factory.release(
artists=[
{
"artist_id": art1.id,
"role": ArtistRole.MAIN
},
{
"artist_id": art2.id,
"role": ArtistRole.MAIN
},
],
conn=db,
)
new_rls = release.create(
title=rls1.title,
artists=[{
"artist_id": art1.id,
"role": ArtistRole.MAIN
}],
release_type=rls1.release_type,
release_year=rls1.release_year,
conn=db,
allow_duplicate=False,
)
assert rls1.id != new_rls.id
def test_fix_album_artists_track_artists(factory: Factory, db: Connection):
rls = factory.release(artists=[], conn=db)
art1 = factory.artist(conn=db)
art2 = factory.artist(conn=db)
factory.track(
release_id=rls.id,
artists=[
{
"artist_id": art1.id,
"role": ArtistRole.MAIN
},
{
"artist_id": art2.id,
"role": ArtistRole.FEATURE
},
],
conn=db,
)
_fix_album_artists(db)
rls = release.from_id(rls.id, db) # type: ignore
assert rls is not None
album_artists = release.artists(rls, db)
assert len(album_artists) == 1
assert album_artists[0]["artist"].id == art1.id
def test_duplicate_genre(factory: Factory, db: Connection):
rls = factory.release(conn=db)
_insert_into_genre_collections(rls, ["1, 2, 3", "2/3"], db)
collections = release.collections(rls, db)
for genre in ["1", "2", "3"]:
col = collection.from_name_type_user(genre, CollectionType.GENRE, db)
assert col in collections
def test_release_collections(factory: Factory, db: Connection):
rls = factory.release(conn=db)
cols = [factory.collection(conn=db) for _ in range(5)]
for col in cols:
collection.add_release(col, rls.id, db)
out = release.collections(rls, db)
assert {c.id for c in cols} == {c.id for c in out}
def test_add_artist(factory: Factory, db: Connection):
rls = factory.release(artists=[], conn=db)
art = factory.artist(conn=db)
release.add_artist(rls, art.id, ArtistRole.MAIN, db)
artists = release.artists(rls, db)
assert len(artists) == 1
assert artists[0]["artist"].id == art.id
def test_releases(factory: Factory, db: Connection):
releases = [factory.release(conn=db) for _ in range(4)]
col = factory.collection(conn=db)
for rls in releases:
collection.add_release(col, rls.id, db)
out = collection.releases(col, db)
assert {r.id for r in releases} == {r.id for r in out}
def test_add_release(factory: Factory, db: Connection):
col = factory.collection(conn=db)
rls = factory.release(conn=db)
new_col = collection.add_release(col, rls.id, db)
assert new_col.num_releases == col.num_releases + 1 # type: ignore
releases = collection.releases(col, db)
assert len(releases) == new_col.num_releases # type: ignore
assert releases[0].id == rls.id
def test_del_release(factory: Factory, db: Connection):
col = factory.collection(conn=db)
rls = factory.release(conn=db)
collection.add_release(col, rls.id, db)
new_col = collection.del_release(col, rls.id, db)
assert new_col.num_releases == col.num_releases - 1 # type: ignore
releases = collection.releases(col, db)
assert releases == []
def test_releases(factory: Factory, db: Connection):
art = factory.artist(conn=db)
releases = {
factory.release(
artists=[{"artist_id": art.id, "role": ArtistRole.MAIN}],
conn=db,
)
for _ in range(4)
}
assert releases == set(artist.releases(art, db))
def test_image(factory: Factory, db: Connection):
col = factory.collection(conn=db)
img = factory.mock_image(conn=db)
rls = factory.release(image_id=img.id, conn=db)
collection.add_release(col, rls.id, db)
new_img = collection.image(col, db)
assert new_img is not None
assert new_img.id == img.id
def test_fetch_or_create_release_fetch(factory: Factory, db: Connection):
rls = factory.release(conn=db)
assert release.from_id(rls.id, db) == _fetch_or_create_release(
tf=mock.Mock(
album=rls.title,
artist_album=[
art["artist"].name for art in release.artists(rls, conn=db)
],
),
conn=db,
)
def test_image(factory: Factory, db: Connection):
ply = factory.playlist(conn=db)
img = factory.mock_image(conn=db)
rls = factory.release(image_id=img.id, conn=db)
trk = factory.track(release_id=rls.id, conn=db)
pentry.create(ply.id, trk.id, db)
new_img = playlist.image(ply, db)
assert new_img is not None
assert new_img.id == img.id
def test_search_filter_year(factory: Factory, db: Connection):
# Create tracks with years we want.
releases = [
factory.release(release_year=year, conn=db) for year in [2014, 2016]
]
wanted = []
for rls in releases:
wanted.extend(
[factory.track(release_id=rls.id, conn=db) for _ in range(2)])
# Create tracks with years we don't want (1 No Year and 5 Unwanted Year).
factory.track(release_id=1, conn=db)
bad_rls = factory.release(release_year=1700, conn=db)
for _ in range(5):
factory.track(release_id=bad_rls.id, conn=db)
# Fetch and compare.
tracks = track.search(db, years=[2014, 2016])
assert set(tracks) == set(wanted)
