def test_create_success(factory: Factory, db: Connection):
ply = factory.playlist(conn=db)
trk = factory.track(conn=db)
ety = pentry.create(ply.id, trk.id, db)
assert ety.track_id == trk.id
assert ety.playlist_id == ply.id
assert ety.position == 1
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_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_search_page(factory: Factory, db: Connection):
for _ in range(5):
factory.collection(conn=db)
c1 = collection.search(db, page=1, per_page=1)[0]
c2 = collection.search(db, page=2, per_page=1)[0]
assert c1 != c2
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_search_page(factory: Factory, db: Connection):
for _ in range(5):
factory.artist(conn=db)
a1 = artist.search(db, page=1, per_page=1)[0]
a2 = artist.search(db, page=2, per_page=1)[0]
assert a1 != a2
def test_count_all(factory: Factory, db: Connection):
for _ in range(5):
factory.artist(conn=db)
count = artist.count(db)
# The extra 1 is the Unknown Artist.
assert count == 5 + 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_search_page(factory: Factory, db: Connection):
for _ in range(5):
factory.playlist(conn=db)
p1 = playlist.search(db, page=1, per_page=1)[0]
p2 = playlist.search(db, page=2, per_page=1)[0]
assert p1 != p2
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_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_page(factory: Factory, db: Connection):
for _ in range(5):
factory.invite(conn=db)
i1 = invite.search(db, page=1, per_page=1)[0]
i2 = invite.search(db, page=2, per_page=1)[0]
assert i1 != i2
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_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_update(
position: int,
final_order: list[int],
factory: Factory,
db: Connection,
):
ply = factory.playlist(conn=db)
entries = [factory.playlist_entry(playlist_id=ply.id, conn=db) for _ in range(5)]
ety = pentry.update(entries[2], position=position, conn=db)
assert ety.position == position
cursor = db.execute(
"""
SELECT id
FROM music__playlists_tracks
WHERE playlist_id = ?
ORDER BY position ASC
""",
(ply.id,),
)
order = [row["id"] for row in cursor]
expected = [entries[i].track_id for i in final_order]
assert order == expected
def test_search_asc(factory: Factory, db: Connection):
for _ in range(5):
factory.track(conn=db)
asc_true = track.search(sort=TrackSort.TITLE, asc=True, conn=db)
asc_false = track.search(sort=TrackSort.TITLE, asc=False, conn=db)
assert asc_true == asc_false[::-1]
def test_update(factory: Factory, db: Connection):
inv = factory.invite(conn=db)
usr, _ = factory.user(conn=db)
new_inv = invite.update(inv, used_by=usr, conn=db)
assert new_inv.used_by == usr.id
assert new_inv == invite.from_id(inv.id, db)
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_sort_title(factory: Factory, db: Connection):
for _ in range(5):
factory.track(conn=db)
out = track.search(sort=TrackSort.TITLE, asc=True, conn=db)
titles = [t.title for t in out]
assert titles == sorted(titles, key=str.casefold)
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_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_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_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_search_created_by(factory: Factory, db: Connection):
usr, _ = factory.user(conn=db)
invs_from_user = [factory.invite(by_user=usr, conn=db) for _ in range(2)]
for _ in range(3):
factory.invite(conn=db)
invs = invite.search(db, created_by=usr.id)
assert set(invs) == set(invs_from_user)
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_search_expired(factory: Factory, db: Connection):
invs = [factory.invite(conn=db) for _ in range(2)]
invs.append(factory.invite(conn=db, expired=True))
out = invite.search(db, include_expired=True)
assert set(i.id for i in out) == set(i.id for i in invs)
out = invite.search(db, include_expired=False)
assert set(out) == set(invs[:2])
def test_add_artist(factory: Factory, db: Connection):
trk = factory.track(conn=db)
art = factory.artist(conn=db)
track.add_artist(trk, art.id, ArtistRole.MAIN, db)
artists = track.artists(trk, db)
assert len(artists) == 2
assert art.id in [a["artist"].id for a in artists]
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)
async def test_register_failure(
db: Connection,
factory: Factory,
quart_client,
):
factory.user(conn=db)
db.commit()
response = await quart_client.post("/api/register", json={"nickname": "admin"})
assert response.status_code == 401
