def resolve_star_artist(_, info: GraphQLResolveInfo, id: int) -> artist.T:
art = artist.from_id(id, info.context.db)
if not art:
raise NotFound(f"Artist {id} does not exist.")
artist.star(art, info.context.user.id, info.context.db)
return art
async def test_unstar_artist(db: Connection, graphql_query, snapshot):
# Artist 4 should be initially starred.
art = artist.from_id(4, db)
assert art is not None
assert artist.starred(art, user_id=1, conn=db)
query = """
mutation {
unstarArtist(id: 4) {
...ArtistFields
}
}
"""
success, data = await graphql_query(query)
assert success is True
snapshot.assert_match(data)
art = artist.from_id(4, db)
assert art is not None
assert not artist.starred(art, user_id=1, conn=db)
def resolve_update_artist(
_,
info: GraphQLResolveInfo,
id: int,
**changes,
) -> artist.T:
art = artist.from_id(id, info.context.db)
if not art:
raise NotFound(f"Artist {id} does not exist.")
return artist.update(art, info.context.db, **convert_keys_case(changes))
async def test_star_artist(db: Connection, graphql_query, snapshot):
query = """
mutation {
starArtist(id: 3) {
...ArtistFields
}
}
"""
success, data = await graphql_query(query)
assert success is True
snapshot.assert_match(data)
art = artist.from_id(3, db)
assert art is not None
assert artist.starred(art, user_id=1, conn=db)
async def test_update_artist(db: Connection, graphql_query, snapshot):
query = """
mutation {
updateArtist(id: 4, name: "New Name") {
...ArtistFields
}
}
"""
success, data = await graphql_query(query)
assert success is True
snapshot.assert_match(data)
art = artist.from_id(4, db)
assert art is not None
assert art.name == "New Name"
async def test_create_artist(db: Connection, graphql_query, snapshot):
query = """
mutation {
createArtist(name: "New Artist") {
...ArtistFields
}
}
"""
success, data = await graphql_query(query)
assert success is True
snapshot.assert_match(data)
art = artist.from_id(data["data"]["createArtist"]["id"], db)
assert art is not None
assert art.name == "New Artist"
def resolve_del_artist_from_release(
_,
info: GraphQLResolveInfo,
releaseId: int,
artistId: int,
role: ArtistRole,
) -> dict:
rls = release.from_id(releaseId, info.context.db)
if not rls:
raise NotFound(f"Release {releaseId} does not exist.")
rls = release.del_artist(rls, artistId, role, info.context.db)
art = artist.from_id(artistId, info.context.db)
return {"release": rls, "artist": art}
def resolve_del_artist_from_track(
_,
info: GraphQLResolveInfo,
trackId: int,
artistId: int,
role: ArtistRole,
) -> dict:
trk = track.from_id(trackId, info.context.db)
if not trk:
raise NotFound("Track does not exist.")
trk = track.del_artist(trk, artistId, role, info.context.db)
art = artist.from_id(artistId, info.context.db)
return {"track": trk, "track_artist": {"role": role, "artist": art}}
def _fetch_or_create_artist(name: str, conn: Connection) -> artist.T:
"""
Try to fetch an artist from the database with the given name. If one doesn't exist,
create it. If ``name`` is empty or ``None``, return the Unknown Artist (ID: 1).
:param name: The name of the artist.
:param conn: A connection to the database.
:return: The fetched/created artist.
"""
if not name:
art = artist.from_id(1, conn)
assert art is not None
return art
try:
return artist.create(name, conn)
except Duplicate as e:
return e.entity
def resolve_artist(obj: Any, info: GraphQLResolveInfo, id: int) -> artist.T:
if art := artist.from_id(id, info.context.db):
return art
def test_fetch_or_create_artist_duplicate(factory: Factory, db: Connection):
art = factory.artist(conn=db)
assert artist.from_id(art.id, db) == _fetch_or_create_artist(art.name, db)
def test_fetch_or_create_artist_unknown(db: Connection):
assert artist.from_id(1, db) == _fetch_or_create_artist("", db)
