91978656a5
Pulls the 284-line artist quality enhancement helper out of
`web_server.py` into a new `core/artists/` package. Flask route handler
split: route + request parsing stay in web_server.py, the body lifts to
a pure function returning `(payload_dict, http_status_code)`.
What `enhance_artist_quality` does:
1. Validate request: track_ids must be non-empty, artist must exist.
2. Build a `track_lookup` from `database.get_artist_full_detail` so each
selected track resolves with its album context.
3. Per track:
- Read current quality tier from the file extension.
- Build `matched_track_data` for the wishlist entry, in priority
order:
- Spotify direct lookup via stored `spotify_track_id` (preferred).
Uses raw API data when available; otherwise rebuilds the payload
and pulls album images via a follow-up `get_album` call.
- Spotify search fallback using matching_engine queries with
artist+title similarity scoring (album-type bonus for albums,
smaller bonus for EPs). Stops at first >= 0.9 confidence match.
- iTunes/fallback source search with the same scoring shape.
- Add to wishlist via `wishlist_service.add_spotify_track_to_wishlist`
with `source_type='enhance'` and a `source_context` carrying the
original file path, format tier, bitrate, original_tier, and
artist_name.
- Tally `enhanced_count` / `failed_count` / per-track failure reasons.
4. Return `{success, enhanced_count, failed_count, failed_tracks}` 200.
Dependencies injected via `ArtistQualityDeps` (7 fields) — spotify_client,
matching_engine, get_database, get_wishlist_service,
get_current_profile_id, get_quality_tier_from_extension,
get_metadata_fallback_client.
Diff vs original after `deps.X` → global X normalization is **1 line of
cosmetic drift** — the success return now uses an explicit `(payload, 200)`
tuple to keep all returns shape-consistent for the wrapper. Flask treats
`jsonify(x)` and `(jsonify(x), 200)` identically. 284 lines orig = 285
lines lifted, body otherwise byte-identical.
Tests: 10 new under tests/artists/test_quality.py covering input
validation (empty track_ids, artist not found), Spotify direct lookup
via raw_data, Spotify direct lookup with enhanced format requiring
album image rebuild, Spotify search fallback, iTunes/fallback source
match path, track-not-found and no-file-path failure modes, complete
no-match failure, and source_context payload assertions (enhance flag,
file path, format tier, bitrate, source_type).
Full suite: 1340 passing (was 1330). Ruff clean.
312 lines
11 KiB
Python
312 lines
11 KiB
Python
"""Tests for core/artists/quality.py — artist quality enhancement helper."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass
|
|
|
|
import pytest
|
|
|
|
from core.artists import quality as aq
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Fakes
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@dataclass
|
|
class _SpotifyTrack:
|
|
id: str = 'sp-1'
|
|
name: str = 'Found'
|
|
artists: list = None
|
|
album: str = 'Album'
|
|
duration_ms: int = 200000
|
|
image_url: str = ''
|
|
popularity: int = 50
|
|
preview_url: str = ''
|
|
external_urls: dict = None
|
|
album_type: str = 'album'
|
|
release_date: str = '2024-01-01'
|
|
|
|
def __post_init__(self):
|
|
if self.artists is None:
|
|
self.artists = ['Artist Name']
|
|
if self.external_urls is None:
|
|
self.external_urls = {}
|
|
|
|
|
|
class _FakeSpotify:
|
|
def __init__(self, track_details=None, search_results=None, album=None):
|
|
self._track_details = track_details
|
|
self._search_results = search_results or []
|
|
self._album = album
|
|
self.search_calls = []
|
|
|
|
def get_track_details(self, track_id):
|
|
return self._track_details
|
|
|
|
def get_album(self, album_id):
|
|
return self._album
|
|
|
|
def search_tracks(self, query, limit=5):
|
|
self.search_calls.append((query, limit))
|
|
return self._search_results
|
|
|
|
|
|
class _FakeMatchingEngine:
|
|
def generate_download_queries(self, track):
|
|
return [f"{track.artists[0]} {track.name}"]
|
|
|
|
def normalize_string(self, s):
|
|
return (s or '').lower().strip()
|
|
|
|
def similarity_score(self, a, b):
|
|
if a == b:
|
|
return 1.0
|
|
if not a or not b:
|
|
return 0.0
|
|
return 0.95 if a in b or b in a else 0.0
|
|
|
|
|
|
class _FakeWishlist:
|
|
def __init__(self):
|
|
self.added = []
|
|
|
|
def add_spotify_track_to_wishlist(self, **kwargs):
|
|
self.added.append(kwargs)
|
|
return True
|
|
|
|
|
|
class _FakeDatabase:
|
|
def __init__(self, artist_detail=None):
|
|
self._artist_detail = artist_detail or {'success': False}
|
|
|
|
def get_artist_full_detail(self, artist_id):
|
|
return self._artist_detail
|
|
|
|
|
|
def _build_deps(
|
|
*,
|
|
spotify=None,
|
|
matching_engine=None,
|
|
artist_detail=None,
|
|
wishlist=None,
|
|
fallback_client=None,
|
|
profile_id=1,
|
|
quality_tier=('mp3_320', 4),
|
|
):
|
|
deps = aq.ArtistQualityDeps(
|
|
spotify_client=spotify,
|
|
matching_engine=matching_engine or _FakeMatchingEngine(),
|
|
get_database=lambda: _FakeDatabase(artist_detail=artist_detail),
|
|
get_wishlist_service=lambda: wishlist or _FakeWishlist(),
|
|
get_current_profile_id=lambda: profile_id,
|
|
get_quality_tier_from_extension=lambda fp: quality_tier,
|
|
get_metadata_fallback_client=lambda: fallback_client,
|
|
)
|
|
return deps
|
|
|
|
|
|
def _artist_with_track(*, track_id='t1', file_path='/file.mp3', spotify_tid=None):
|
|
return {
|
|
'success': True,
|
|
'artist': {'name': 'Artist Name'},
|
|
'albums': [{
|
|
'id': 'a1',
|
|
'title': 'Album X',
|
|
'tracks': [{
|
|
'id': track_id,
|
|
'title': 'Track One',
|
|
'file_path': file_path,
|
|
'spotify_track_id': spotify_tid,
|
|
'track_number': 1,
|
|
'duration': 180000,
|
|
'bitrate': 320,
|
|
}],
|
|
}],
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Input validation
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_no_track_ids_returns_400():
|
|
deps = _build_deps()
|
|
payload, status = aq.enhance_artist_quality('artist-1', [], deps)
|
|
assert status == 400
|
|
assert payload == {"success": False, "error": "No track IDs provided"}
|
|
|
|
|
|
def test_artist_not_found_returns_404():
|
|
deps = _build_deps(artist_detail={'success': False})
|
|
payload, status = aq.enhance_artist_quality('artist-x', ['t1'], deps)
|
|
assert status == 404
|
|
assert payload == {"success": False, "error": "Artist not found"}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Spotify direct lookup (priority 1)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_spotify_direct_lookup_via_track_id_uses_raw_data():
|
|
"""Track has spotify_track_id → get_track_details, raw_data fed to wishlist."""
|
|
raw = {'id': 'sp-stored', 'name': 'Track One', 'artists': [{'name': 'Artist Name'}],
|
|
'album': {'name': 'Album X', 'images': [{'url': 'http://i'}]}, 'duration_ms': 180000}
|
|
spotify = _FakeSpotify(track_details={'raw_data': raw})
|
|
wishlist = _FakeWishlist()
|
|
deps = _build_deps(
|
|
spotify=spotify,
|
|
artist_detail=_artist_with_track(spotify_tid='sp-stored'),
|
|
wishlist=wishlist,
|
|
)
|
|
|
|
payload, status = aq.enhance_artist_quality('artist-1', ['t1'], deps)
|
|
|
|
assert status == 200
|
|
assert payload['enhanced_count'] == 1
|
|
assert wishlist.added[0]['spotify_track_data'] == raw
|
|
|
|
|
|
def test_spotify_direct_lookup_enhanced_format_rebuilds_payload():
|
|
"""Track details without raw_data → rebuild payload with album images via get_album."""
|
|
enhanced = {'name': 'Track One', 'artists': ['Artist Name'],
|
|
'album': {'id': 'alb-id', 'name': 'Album X'},
|
|
'duration_ms': 180000, 'track_number': 1, 'disc_number': 1}
|
|
full_album = {'images': [{'url': 'http://art'}]}
|
|
spotify = _FakeSpotify(track_details=enhanced, album=full_album)
|
|
wishlist = _FakeWishlist()
|
|
deps = _build_deps(
|
|
spotify=spotify,
|
|
artist_detail=_artist_with_track(spotify_tid='sp-stored'),
|
|
wishlist=wishlist,
|
|
)
|
|
|
|
payload, _ = aq.enhance_artist_quality('artist-1', ['t1'], deps)
|
|
|
|
assert payload['enhanced_count'] == 1
|
|
md = wishlist.added[0]['spotify_track_data']
|
|
assert md['album']['images'] == [{'url': 'http://art'}]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Spotify search fallback (priority 2)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_spotify_search_fallback_when_no_stored_id():
|
|
"""No spotify_track_id → search via matching_engine, pick best match."""
|
|
track = _SpotifyTrack(name='Track One', artists=['Artist Name'])
|
|
raw = {'id': 'sp-search', 'name': 'Track One', 'artists': [{'name': 'Artist Name'}],
|
|
'album': {'name': 'Album X'}}
|
|
spotify = _FakeSpotify(track_details={'raw_data': raw}, search_results=[track])
|
|
wishlist = _FakeWishlist()
|
|
deps = _build_deps(
|
|
spotify=spotify,
|
|
artist_detail=_artist_with_track(spotify_tid=None),
|
|
wishlist=wishlist,
|
|
)
|
|
|
|
payload, _ = aq.enhance_artist_quality('artist-1', ['t1'], deps)
|
|
|
|
assert payload['enhanced_count'] == 1
|
|
assert wishlist.added[0]['spotify_track_data'] == raw
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Fallback source (iTunes/Deezer)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_fallback_source_when_spotify_none():
|
|
"""Spotify client None → iTunes/fallback search runs."""
|
|
fallback_track = _SpotifyTrack(id='it-1', name='Track One', artists=['Artist Name'],
|
|
image_url='http://it')
|
|
fallback_track.track_number = 1
|
|
fallback_track.disc_number = 1
|
|
fallback = type('FB', (), {
|
|
'search_tracks': lambda self, q, limit=5: [fallback_track],
|
|
})()
|
|
wishlist = _FakeWishlist()
|
|
deps = _build_deps(
|
|
spotify=None,
|
|
artist_detail=_artist_with_track(),
|
|
wishlist=wishlist,
|
|
fallback_client=fallback,
|
|
)
|
|
|
|
payload, _ = aq.enhance_artist_quality('artist-1', ['t1'], deps)
|
|
|
|
assert payload['enhanced_count'] == 1
|
|
md = wishlist.added[0]['spotify_track_data']
|
|
assert md['id'] == 'it-1'
|
|
assert md['album']['images'] == [{'url': 'http://it', 'height': 600, 'width': 600}]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Failure modes
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_track_not_in_artist_detail_marked_failed():
|
|
"""Track ID provided but missing from artist's albums → failed_tracks entry."""
|
|
deps = _build_deps(artist_detail=_artist_with_track(track_id='t1'))
|
|
payload, _ = aq.enhance_artist_quality('artist-1', ['t99'], deps)
|
|
|
|
assert payload['enhanced_count'] == 0
|
|
assert payload['failed_count'] == 1
|
|
assert payload['failed_tracks'][0]['reason'] == 'Track not found'
|
|
|
|
|
|
def test_track_with_no_file_path_marked_failed():
|
|
"""Track has no file_path → failed reason 'No file path'."""
|
|
detail = _artist_with_track()
|
|
detail['albums'][0]['tracks'][0]['file_path'] = None
|
|
deps = _build_deps(artist_detail=detail)
|
|
payload, _ = aq.enhance_artist_quality('artist-1', ['t1'], deps)
|
|
|
|
assert payload['failed_count'] == 1
|
|
assert payload['failed_tracks'][0]['reason'] == 'No file path'
|
|
|
|
|
|
def test_no_match_anywhere_marked_failed():
|
|
"""No Spotify match AND no fallback match → failed reason 'No Spotify or fallback match'."""
|
|
spotify = _FakeSpotify(track_details=None, search_results=[])
|
|
fallback = type('FB', (), {
|
|
'search_tracks': lambda self, q, limit=5: [],
|
|
})()
|
|
deps = _build_deps(
|
|
spotify=spotify,
|
|
artist_detail=_artist_with_track(),
|
|
fallback_client=fallback,
|
|
)
|
|
|
|
payload, _ = aq.enhance_artist_quality('artist-1', ['t1'], deps)
|
|
|
|
assert payload['failed_count'] == 1
|
|
assert 'No Spotify or fallback match' in payload['failed_tracks'][0]['reason']
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Wishlist source_context payload
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_wishlist_source_context_carries_quality_metadata():
|
|
"""source_context includes original_file_path, format tier, bitrate, artist_name."""
|
|
raw = {'id': 'sp-1', 'name': 'Track One', 'artists': [{'name': 'Artist Name'}],
|
|
'album': {'name': 'Album X'}}
|
|
spotify = _FakeSpotify(track_details={'raw_data': raw})
|
|
wishlist = _FakeWishlist()
|
|
deps = _build_deps(
|
|
spotify=spotify,
|
|
artist_detail=_artist_with_track(spotify_tid='sp-1'),
|
|
wishlist=wishlist,
|
|
quality_tier=('mp3_192', 4),
|
|
)
|
|
|
|
aq.enhance_artist_quality('artist-1', ['t1'], deps)
|
|
|
|
ctx = wishlist.added[0]['source_context']
|
|
assert ctx['enhance'] is True
|
|
assert ctx['original_file_path'] == '/file.mp3'
|
|
assert ctx['original_format'] == 'mp3_192'
|
|
assert ctx['original_bitrate'] == 320
|
|
assert ctx['original_tier'] == 4
|
|
assert ctx['artist_name'] == 'Artist Name'
|
|
assert wishlist.added[0]['source_type'] == 'enhance'
|