danvics/soulsync
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1
soulsync/tests/search/test_search_by_id.py
BoulderBadgeDad b2de64e87d Search: extend pasted-link resolution to Discogs (#813) 
#775 already resolves pasted Spotify / Apple / MusicBrainz / Deezer links to an
exact artist/album/track on the Search page. Added Discogs to that set (the one
source in the request not already covered; Amazon left out per request).

- by_id resolver: discogs in SUPPORTED_SOURCES + _KNOWN_HOSTS; parse
  /artist/<id>-slug, /release/<id>-slug, /master/<id>-slug (master→album), and
  strip the slug to the leading numeric id. Discogs has no standalone track
  URLs (tracks live inside a release), so artist + album resolve.
- Fetch dispatch: discogs albums use get_album(include_tracks=False) like
  itunes/musicbrainz; artists use get_artist; both already return the common
  normalized card shape. Updated the not-a-link hint to mention Discogs.

Frontend needs no change — it adopts whatever source the resolver returns and
Discogs is already a search source. Tests: parse release/master/artist
(slug-stripped, scheme-less) + resolve release→get_album(numeric id) and
artist→get_artist. 43 by_id tests pass.
2026-06-08 14:37:48 -07:00

501 lines
18 KiB
Python
Raw Blame History

"""Tests for core/search/by_id.py — paste-a-link/ID metadata resolution (#775).
Covers the three seams:
- ``parse_metadata_identifier`` — provider URLs, the ``spotify:`` URI, and
bare IDs (UUID → MusicBrainz, base62 → Spotify, numeric → Deezer/iTunes
fan-out with active-source bias).
- the shaping adapters — projecting each source's get-by-id dict (which
differ in their ``artists`` field shape) onto the common card shape.
- ``resolve_identifier`` — first-resolving-target-wins, kind fallback
(album→track), source fan-out, and the not-found regression.
Clients are injected via ``client_resolver`` so nothing touches the network
or real config.
"""
from __future__ import annotations
from core.search import by_id
from core.search.by_id import LookupTarget
# ---------------------------------------------------------------------------
# Fakes — a client exposing only the get-by-id methods the resolver calls.
# Each "source" can return album/track dicts in its native shape.
# ---------------------------------------------------------------------------
class _FakeClient:
def __init__(self, album=None, track=None, artist=None, name='fake'):
self._album = album
self._track = track
self._artist = artist
self._name = name
self.album_calls: list[str] = []
self.track_calls: list[str] = []
self.artist_calls: list[str] = []
# Spotify / iTunes / MusicBrainz album-by-id
def get_album(self, identifier, include_tracks=True):
self.album_calls.append(identifier)
return self._album
# Deezer album-by-id (different method name)
def get_album_metadata(self, identifier, include_tracks=True):
self.album_calls.append(identifier)
return self._album
# Uniform track-by-id
def get_track_details(self, identifier):
self.track_calls.append(identifier)
return self._track
# Spotify / iTunes / MusicBrainz artist-by-id
def get_artist(self, identifier):
self.artist_calls.append(identifier)
return self._artist
# Deezer artist-by-id (different method name)
def get_artist_info(self, identifier):
self.artist_calls.append(identifier)
return self._artist
def _resolver_from(mapping):
"""Build a client_resolver from {source: client}."""
return lambda source: mapping.get(source)
# ---------------------------------------------------------------------------
# parse_metadata_identifier — URLs
# ---------------------------------------------------------------------------
def test_parse_spotify_album_url():
out = by_id.parse_metadata_identifier(
'https://open.spotify.com/album/4aawyAB9vmqN3uQ7FjRGTy'
)
assert out == [LookupTarget('spotify', 'album', '4aawyAB9vmqN3uQ7FjRGTy')]
def test_parse_spotify_track_url_with_intl_prefix():
out = by_id.parse_metadata_identifier(
'https://open.spotify.com/intl-de/track/11dFghVXANMlKmJXsNCbNl'
)
assert out == [LookupTarget('spotify', 'track', '11dFghVXANMlKmJXsNCbNl')]
def test_parse_spotify_uri():
assert by_id.parse_metadata_identifier('spotify:album:ABC') == [
LookupTarget('spotify', 'album', 'ABC')
]
assert by_id.parse_metadata_identifier('spotify:track:XYZ') == [
LookupTarget('spotify', 'track', 'XYZ')
]
def test_parse_apple_album_url():
out = by_id.parse_metadata_identifier(
'https://music.apple.com/us/album/in-rainbows/1109714933'
)
assert out == [LookupTarget('itunes', 'album', '1109714933')]
def test_parse_apple_track_url_uses_i_param():
out = by_id.parse_metadata_identifier(
'https://music.apple.com/us/album/in-rainbows/1109714933?i=1109714934'
)
assert out == [LookupTarget('itunes', 'track', '1109714934')]
def test_parse_apple_song_url():
out = by_id.parse_metadata_identifier(
'https://music.apple.com/us/song/15-step/1109714938'
)
assert out == [LookupTarget('itunes', 'track', '1109714938')]
def test_parse_musicbrainz_release_group_url():
mbid = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890'
out = by_id.parse_metadata_identifier(
f'https://musicbrainz.org/release-group/{mbid}'
)
assert out == [LookupTarget('musicbrainz', 'album', mbid)]
def test_parse_musicbrainz_recording_url_is_track():
mbid = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890'
out = by_id.parse_metadata_identifier(
f'https://musicbrainz.org/recording/{mbid}'
)
assert out == [LookupTarget('musicbrainz', 'track', mbid)]
def test_parse_deezer_album_url_with_locale():
out = by_id.parse_metadata_identifier('https://www.deezer.com/en/album/302127')
assert out == [LookupTarget('deezer', 'album', '302127')]
def test_parse_deezer_track_url_no_scheme():
out = by_id.parse_metadata_identifier('www.deezer.com/track/3135556')
assert out == [LookupTarget('deezer', 'track', '3135556')]
def test_parse_spotify_url_without_scheme_or_www():
# Known host detected even without a scheme.
out = by_id.parse_metadata_identifier('open.spotify.com/album/4aawyAB9vmqN3uQ7FjRGTy')
assert out == [LookupTarget('spotify', 'album', '4aawyAB9vmqN3uQ7FjRGTy')]
# ---------------------------------------------------------------------------
# parse_metadata_identifier — artist links
# ---------------------------------------------------------------------------
def test_parse_spotify_artist_url():
out = by_id.parse_metadata_identifier(
'https://open.spotify.com/artist/3TVXtAsR1Inumwj472S9r4'
)
assert out == [LookupTarget('spotify', 'artist', '3TVXtAsR1Inumwj472S9r4')]
def test_parse_spotify_artist_uri():
assert by_id.parse_metadata_identifier('spotify:artist:ABC') == [
LookupTarget('spotify', 'artist', 'ABC')
]
def test_parse_apple_artist_url():
out = by_id.parse_metadata_identifier(
'https://music.apple.com/us/artist/kendrick-lamar/368183298'
)
assert out == [LookupTarget('itunes', 'artist', '368183298')]
def test_parse_musicbrainz_artist_url():
mbid = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890'
out = by_id.parse_metadata_identifier(f'https://musicbrainz.org/artist/{mbid}')
assert out == [LookupTarget('musicbrainz', 'artist', mbid)]
def test_parse_deezer_artist_url():
out = by_id.parse_metadata_identifier('https://www.deezer.com/artist/13')
assert out == [LookupTarget('deezer', 'artist', '13')]
# ---------------------------------------------------------------------------
# parse_metadata_identifier — bare IDs are rejected (links only)
# ---------------------------------------------------------------------------
def test_parse_bare_numeric_id_rejected():
# The footgun case (#775 follow-up): a bare number has no source/type, so
# it must NOT resolve to whatever album happens to own that id.
assert by_id.parse_metadata_identifier('525046') == []
def test_parse_bare_uuid_rejected():
assert by_id.parse_metadata_identifier(
'a1b2c3d4-e5f6-7890-abcd-ef1234567890'
) == []
def test_parse_bare_base62_rejected():
assert by_id.parse_metadata_identifier('4aawyAB9vmqN3uQ7FjRGTy') == []
def test_parse_empty_and_garbage_return_empty():
assert by_id.parse_metadata_identifier('') == []
assert by_id.parse_metadata_identifier(' ') == []
assert by_id.parse_metadata_identifier('not an id!!') == []
# Unknown domain → no targets.
assert by_id.parse_metadata_identifier('https://example.com/album/1') == []
# ---------------------------------------------------------------------------
# Shaping adapters
# ---------------------------------------------------------------------------
def test_album_card_from_spotify_shaped_dict():
d = {
'id': 'abc',
'name': 'OK Computer',
'artists': [{'name': 'Radiohead', 'id': 'r1'}],
'images': [{'url': 'http://img/big.jpg', 'height': 640, 'width': 640}],
'release_date': '1997-05-21',
'total_tracks': 12,
'album_type': 'album',
'external_urls': {'spotify': 'http://spot/abc'},
}
card = by_id.album_dict_to_card(d)
assert card['id'] == 'abc'
assert card['name'] == 'OK Computer'
assert card['artist'] == 'Radiohead'
assert card['image_url'] == 'http://img/big.jpg'
assert card['total_tracks'] == 12
assert card['external_urls'] == {'spotify': 'http://spot/abc'}
def test_album_card_carries_optional_musicbrainz_fields():
d = {
'id': 'mbid', 'name': 'Kid A', 'artists': [{'name': 'Radiohead'}],
'images': [], 'release_date': '2000', 'total_tracks': 10,
'album_type': 'album', 'country': 'GB', 'label': 'Parlophone',
'release_group_id': 'rg1', 'external_urls': {},
}
card = by_id.album_dict_to_card(d)
assert card['country'] == 'GB'
assert card['label'] == 'Parlophone'
assert card['release_group_id'] == 'rg1'
def test_track_card_handles_list_of_string_artists():
# Spotify/iTunes shape: artists is a list of plain strings.
d = {
'id': 't1', 'name': 'Paranoid Android',
'artists': ['Radiohead'],
'album': {'name': 'OK Computer', 'release_date': '1997'},
'duration_ms': 387000,
}
card = by_id.track_dict_to_card(d)
assert card['artist'] == 'Radiohead'
assert card['album'] == 'OK Computer'
assert card['duration_ms'] == 387000
assert card['release_date'] == '1997'
def test_track_card_handles_list_of_dict_artists_and_album_image():
# MusicBrainz shape: artists is a list of dicts; album carries images.
d = {
'id': 't2', 'name': 'Idioteque',
'artists': [{'name': 'Radiohead', 'id': ''}],
'album': {
'name': 'Kid A',
'images': [{'url': 'http://img/kida.jpg', 'height': 250, 'width': 250}],
'release_date': '2000',
},
'duration_ms': 300000,
'external_urls': {'musicbrainz': 'http://mb/t2'},
}
card = by_id.track_dict_to_card(d)
assert card['artist'] == 'Radiohead'
assert card['album'] == 'Kid A'
assert card['image_url'] == 'http://img/kida.jpg'
assert card['external_urls'] == {'musicbrainz': 'http://mb/t2'}
def test_join_artists_empty_is_unknown():
assert by_id._join_artists([]) == 'Unknown Artist'
assert by_id._join_artists(None) == 'Unknown Artist'
def test_artist_card_from_spotify_shaped_dict():
d = {
'id': 'a1', 'name': 'Radiohead',
'images': [{'url': 'http://img/rh.jpg', 'height': 640, 'width': 640}],
'external_urls': {'spotify': 'http://spot/a1'},
'genres': ['rock'], 'popularity': 80,
}
card = by_id.artist_dict_to_card(d)
assert card == {
'id': 'a1',
'name': 'Radiohead',
'image_url': 'http://img/rh.jpg',
'external_urls': {'spotify': 'http://spot/a1'},
}
# ---------------------------------------------------------------------------
# resolve_identifier — end-to-end with fake clients
# ---------------------------------------------------------------------------
_SPOTIFY_ALBUM = {
'id': 'abc', 'name': 'OK Computer',
'artists': [{'name': 'Radiohead'}],
'images': [{'url': 'http://i/a.jpg'}],
'release_date': '1997', 'total_tracks': 12, 'album_type': 'album',
'external_urls': {'spotify': 'http://s/abc'},
}
def test_resolve_spotify_album_link():
client = _FakeClient(album=_SPOTIFY_ALBUM)
res = by_id.resolve_identifier(
'https://open.spotify.com/album/abc', deps=None,
client_resolver=_resolver_from({'spotify': client}),
)
assert res['available'] is True
assert res['source'] == 'spotify'
assert len(res['albums']) == 1
assert res['albums'][0]['name'] == 'OK Computer'
assert res['tracks'] == []
assert client.album_calls == ['abc']
assert client.track_calls == [] # kind pinned to album — no track probe
def test_resolve_deezer_album_uses_get_album_metadata():
client = _FakeClient(album={'id': '302127', 'name': 'Discovery',
'artists': [{'name': 'Daft Punk'}], 'images': [],
'release_date': '2001', 'total_tracks': 14,
'album_type': 'album', 'external_urls': {}})
res = by_id.resolve_identifier(
'https://www.deezer.com/album/302127', deps=None,
client_resolver=_resolver_from({'deezer': client}),
)
assert res['available'] is True
assert res['source'] == 'deezer'
assert res['albums'][0]['name'] == 'Discovery'
assert client.album_calls == ['302127']
def test_resolve_track_link():
# A track URL pins kind=track — only get_track_details is called.
client = _FakeClient(album=None, track={
'id': 't1', 'name': 'Creep', 'artists': ['Radiohead'],
'album': {'name': 'Pablo Honey'}, 'duration_ms': 238000,
})
res = by_id.resolve_identifier(
'https://open.spotify.com/track/t1', deps=None,
client_resolver=_resolver_from({'spotify': client}),
)
assert res['available'] is True
assert res['tracks'][0]['name'] == 'Creep'
assert res['albums'] == []
assert client.album_calls == [] # kind pinned to track — no album probe
assert client.track_calls == ['t1']
def test_resolve_artist_link():
# An artist URL pins kind=artist — only get_artist is called.
client = _FakeClient(artist={
'id': 'a1', 'name': 'Radiohead',
'images': [{'url': 'http://i/rh.jpg'}],
'external_urls': {'spotify': 'http://s/a1'},
})
res = by_id.resolve_identifier(
'https://open.spotify.com/artist/a1', deps=None,
client_resolver=_resolver_from({'spotify': client}),
)
assert res['available'] is True
assert res['source'] == 'spotify'
assert res['artists'][0]['name'] == 'Radiohead'
assert res['albums'] == [] and res['tracks'] == []
assert client.artist_calls == ['a1']
assert client.album_calls == [] and client.track_calls == []
def test_resolve_deezer_artist_uses_get_artist_info():
client = _FakeClient(artist={'id': '13', 'name': 'Daft Punk',
'images': [], 'external_urls': {}})
res = by_id.resolve_identifier(
'https://www.deezer.com/artist/13', deps=None,
client_resolver=_resolver_from({'deezer': client}),
)
assert res['available'] is True
assert res['source'] == 'deezer'
assert res['artists'][0]['name'] == 'Daft Punk'
assert client.artist_calls == ['13']
def test_resolve_bare_id_rejected_with_hint():
# The #775 follow-up regression: a bare number must not resolve; it
# returns not-found with a link hint instead of an unrelated album.
called = []
res = by_id.resolve_identifier(
'525046', deps=None,
client_resolver=lambda s: called.append(s), # must never be invoked
)
assert res['available'] is False
assert res['albums'] == [] and res['tracks'] == []
assert 'link' in res['message'].lower()
assert called == [] # no source was even probed
def test_resolve_unavailable_client_is_skipped():
# Spotify client is None (unauthed) — resolver returns not-found, no crash.
res = by_id.resolve_identifier(
'https://open.spotify.com/album/abc', deps=None,
client_resolver=_resolver_from({'spotify': None}),
)
assert res['available'] is False
assert res['albums'] == [] and res['tracks'] == []
# The source we tried is reported even on miss.
assert res['source'] == 'spotify'
assert res['message']
def test_resolve_client_exception_does_not_propagate():
def boom(_source):
raise RuntimeError('client init failed')
res = by_id.resolve_identifier(
'https://open.spotify.com/album/abc', deps=None, client_resolver=boom,
)
assert res['available'] is False
def test_resolve_unrecognized_identifier_returns_empty():
res = by_id.resolve_identifier(
'definitely not a link', deps=None,
client_resolver=_resolver_from({}),
)
assert res['available'] is False
assert res['query'] == 'definitely not a link'
def test_resolve_get_album_returning_none_yields_not_found():
# Regression: a pinned-kind link whose lookup returns None must report
# not-found, not raise or fabricate a card.
client = _FakeClient(album=None)
res = by_id.resolve_identifier(
'https://open.spotify.com/album/missing', deps=None,
client_resolver=_resolver_from({'spotify': client}),
)
assert res['available'] is False
assert res['albums'] == []
# ── Discogs (#813 — extend paste-link to Discogs) ──────────────────────────
def test_parse_discogs_release_url_strips_slug():
out = by_id.parse_metadata_identifier(
'https://www.discogs.com/release/678910-Some-Album-Title')
assert out == [by_id.LookupTarget('discogs', 'album', '678910')]
def test_parse_discogs_master_url_is_album():
out = by_id.parse_metadata_identifier(
'https://www.discogs.com/master/555-A-Master')
assert out == [by_id.LookupTarget('discogs', 'album', '555')]
def test_parse_discogs_artist_url():
out = by_id.parse_metadata_identifier(
'https://www.discogs.com/artist/12345-Some-Artist')
assert out == [by_id.LookupTarget('discogs', 'artist', '12345')]
def test_parse_discogs_url_no_scheme():
out = by_id.parse_metadata_identifier('discogs.com/release/999-X')
assert out == [by_id.LookupTarget('discogs', 'album', '999')]
def test_resolve_discogs_release_uses_get_album_with_numeric_id():
client = _FakeClient(album={'id': '678910', 'name': 'Some Album',
'artists': [{'name': 'Some Artist'}]})
res = by_id.resolve_identifier(
'https://www.discogs.com/release/678910-Some-Album-Title', deps=None,
client_resolver=_resolver_from({'discogs': client}))
assert res['available'] is True and res['source'] == 'discogs'
assert res['albums'] and res['albums'][0]['name'] == 'Some Album'
assert client.album_calls == ['678910'] # numeric id, slug stripped
def test_resolve_discogs_artist():
client = _FakeClient(artist={'id': '12345', 'name': 'Some Artist'})
res = by_id.resolve_identifier(
'https://www.discogs.com/artist/12345-Some-Artist', deps=None,
client_resolver=_resolver_from({'discogs': client}))
assert res['available'] is True and res['source'] == 'discogs'
assert res['artists'] and res['artists'][0]['name'] == 'Some Artist'
assert client.artist_calls == ['12345']
def test_discogs_in_supported_sources():
assert 'discogs' in by_id.SUPPORTED_SOURCES
Reference in a new issue View git blame Copy permalink