mirror of
https://github.com/beetbox/beets.git
synced 2026-05-16 14:51:03 -04:00
580 lines
18 KiB
Python
580 lines
18 KiB
Python
"""Tests for the 'tidal' plugin."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from typing import TYPE_CHECKING
|
|
from unittest.mock import Mock
|
|
|
|
import pytest
|
|
|
|
from beets.library.models import Item
|
|
from beets.test.helper import PluginTestCase
|
|
from beetsplug.tidal import TidalPlugin
|
|
|
|
if TYPE_CHECKING:
|
|
from beetsplug.tidal.api_types import (
|
|
AlbumAttributes,
|
|
TidalAlbum,
|
|
TidalArtist,
|
|
TidalTrack,
|
|
TrackAttributes,
|
|
)
|
|
|
|
|
|
def _make_artist(id: str, name: str) -> TidalArtist:
|
|
return {
|
|
"id": id,
|
|
"type": "artists",
|
|
"attributes": {"name": name, "popularity": 0.5},
|
|
}
|
|
|
|
|
|
def _make_album(
|
|
id: str,
|
|
title: str,
|
|
tracks: list[TidalTrack],
|
|
artist_ids: list[str],
|
|
release_date: str = "2024-01-15",
|
|
version: str | None = None,
|
|
) -> tuple[TidalAlbum, dict[str, TidalTrack], dict[str, TidalArtist]]:
|
|
artist_lookup = {
|
|
aid: _make_artist(aid, f"Artist {aid}") for aid in artist_ids
|
|
}
|
|
track_lookup = {t["id"]: t for t in tracks}
|
|
|
|
attrs: AlbumAttributes = {
|
|
"albumType": "ALBUM",
|
|
"barcodeId": "123456",
|
|
"duration": "PT45M",
|
|
"explicit": False,
|
|
"mediaTags": [],
|
|
"numberOfItems": len(tracks),
|
|
"numberOfVolumes": 1,
|
|
"popularity": 0.5,
|
|
"title": title,
|
|
"releaseDate": release_date,
|
|
}
|
|
if version:
|
|
attrs["version"] = version
|
|
|
|
album: TidalAlbum = {
|
|
"id": id,
|
|
"type": "albums",
|
|
"attributes": attrs,
|
|
"relationships": {
|
|
"artists": {
|
|
"data": [{"id": aid, "type": "artists"} for aid in artist_ids],
|
|
"links": {},
|
|
},
|
|
"items": {
|
|
"data": [{"id": t["id"], "type": "tracks"} for t in tracks],
|
|
"links": {},
|
|
},
|
|
},
|
|
}
|
|
return album, track_lookup, artist_lookup
|
|
|
|
|
|
def _make_track(
|
|
id: str,
|
|
title: str,
|
|
duration: str = "PT3M30S",
|
|
isrc: str = "ISRC123",
|
|
artist_ids: list[str] | None = None,
|
|
version: str | None = None,
|
|
) -> TidalTrack:
|
|
attrs: TrackAttributes = {
|
|
"title": title,
|
|
"duration": duration,
|
|
"explicit": False,
|
|
"isrc": isrc,
|
|
"key": "C",
|
|
"keyScale": "MAJOR",
|
|
"mediaTags": [],
|
|
"popularity": 0.5,
|
|
}
|
|
if version:
|
|
attrs["version"] = version
|
|
return {
|
|
"id": id,
|
|
"type": "tracks",
|
|
"attributes": attrs,
|
|
"relationships": {
|
|
"artists": {
|
|
"data": [
|
|
{"id": aid, "type": "artists"} for aid in (artist_ids or [])
|
|
],
|
|
"links": {},
|
|
},
|
|
},
|
|
}
|
|
|
|
|
|
class TidalPluginTest(PluginTestCase):
|
|
plugin = "tidal"
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.tidal = TidalPlugin()
|
|
|
|
|
|
class TestAlbumParsing(TidalPluginTest):
|
|
"""High-level tests for album parsing."""
|
|
|
|
def test_parse_album(self):
|
|
track = _make_track("t1", "My Song", "PT3M30S", "ISRC001", ["a1"])
|
|
album, track_lookup, artist_lookup = _make_album(
|
|
"al1", "My Album", [track], ["a1"]
|
|
)
|
|
|
|
info = self.tidal._get_album_info(album, track_lookup, artist_lookup)
|
|
|
|
assert info.album == "My Album"
|
|
assert info.album_id == "al1"
|
|
assert len(info.tracks) == 1
|
|
assert info.tracks[0].title == "My Song"
|
|
|
|
def test_parse_album_with_multiple_tracks(self):
|
|
tracks = [
|
|
_make_track("t1", "Track One", "PT3M", "ISRC1", ["a1"]),
|
|
_make_track("t2", "Track Two", "PT4M", "ISRC2", ["a1"]),
|
|
]
|
|
album, track_lookup, artist_lookup = _make_album(
|
|
"al2", "Album Two", tracks, ["a1"]
|
|
)
|
|
|
|
info = self.tidal._get_album_info(
|
|
album,
|
|
track_lookup,
|
|
artist_lookup,
|
|
)
|
|
|
|
assert len(info.tracks) == 2
|
|
assert info.tracks[0].index == 1
|
|
assert info.tracks[1].index == 2
|
|
|
|
def test_parse_album_with_version(self):
|
|
"""Album title should have version appended."""
|
|
track = _make_track("t1", "My Song", "PT3M", "ISRC001", ["a1"])
|
|
album, track_lookup, artist_lookup = _make_album(
|
|
"al3", "My Album", [track], ["a1"], version="Deluxe Edition"
|
|
)
|
|
|
|
info = self.tidal._get_album_info(album, track_lookup, artist_lookup)
|
|
|
|
assert info.album == "My Album (Deluxe Edition)"
|
|
|
|
|
|
class TestTrackParsing(TidalPluginTest):
|
|
"""High-level tests for track parsing."""
|
|
|
|
def test_parse_track(self):
|
|
track = _make_track("t1", "My Track", "PT4M", "ISRC456", ["a1"])
|
|
artist_lookup = {"a1": _make_artist("a1", "My Artist")}
|
|
|
|
info = self.tidal._get_track_info(track, artist_lookup)
|
|
|
|
assert info.title == "My Track"
|
|
assert info.track_id == "t1"
|
|
assert info.duration == 240 # PT4M = 240 seconds
|
|
assert info.isrc == "ISRC456"
|
|
assert info.artist == "My Artist"
|
|
|
|
def test_parse_track_with_version(self):
|
|
"""Track title should have version appended."""
|
|
track = _make_track(
|
|
"t2", "My Song", "PT3M", "ISRC002", ["a1"], version="Remastered"
|
|
)
|
|
artist_lookup = {"a1": _make_artist("a1", "My Artist")}
|
|
|
|
info = self.tidal._get_track_info(track, artist_lookup)
|
|
|
|
assert info.title == "My Song (Remastered)"
|
|
|
|
|
|
class TestTrackForID(TidalPluginTest):
|
|
"""Tests for track_for_id with mocked API."""
|
|
|
|
def test_track_for_id(self):
|
|
"""Test fetching track by ID via API."""
|
|
track = _make_track("490839595", "API Track", "PT3M", "ISRC001", ["a1"])
|
|
artist = _make_artist("a1", "API Artist")
|
|
|
|
self.tidal.api.get_tracks = Mock(
|
|
return_value={
|
|
"data": [track],
|
|
"included": [artist],
|
|
}
|
|
)
|
|
|
|
info = self.tidal.track_for_id("https://tidal.com/track/490839595")
|
|
self.tidal.api.get_tracks.assert_called_once()
|
|
|
|
assert info is not None
|
|
assert info.title == "API Track"
|
|
assert info.track_id == "490839595"
|
|
assert info.artist == "API Artist"
|
|
|
|
def test_track_for_id_not_found(self):
|
|
"""Test track_for_id returns None when not found."""
|
|
self.tidal.api.get_tracks = Mock(return_value={"data": []})
|
|
info = self.tidal.track_for_id("https://tidal.com/track/490839595")
|
|
assert info is None
|
|
|
|
info = self.tidal.track_for_id("does_not_exist")
|
|
assert info is None
|
|
|
|
|
|
class TestTracksForIDs(TidalPluginTest):
|
|
"""Tests for tracks_for_ids with mocked API."""
|
|
|
|
def test_tracks_for_ids(self):
|
|
"""Test fetching multiple tracks by IDs via API."""
|
|
track1 = _make_track(
|
|
"490839595", "API Track 1", "PT3M", "ISRC001", ["a1"]
|
|
)
|
|
track2 = _make_track(
|
|
"490839596", "API Track 2", "PT4M", "ISRC002", ["a1"]
|
|
)
|
|
artist = _make_artist("a1", "API Artist")
|
|
|
|
self.tidal.api.get_tracks = Mock(
|
|
return_value={
|
|
"data": [track1, track2],
|
|
"included": [artist],
|
|
}
|
|
)
|
|
|
|
results = list(
|
|
self.tidal.tracks_for_ids(
|
|
[
|
|
"https://tidal.com/track/490839595",
|
|
"https://tidal.com/track/490839596",
|
|
]
|
|
)
|
|
)
|
|
self.tidal.api.get_tracks.assert_called_once()
|
|
assert len(results) == 2
|
|
assert results[0] is not None
|
|
assert results[0].title == "API Track 1"
|
|
assert results[1] is not None
|
|
assert results[1].title == "API Track 2"
|
|
|
|
def test_tracks_for_ids_with_missing(self):
|
|
"""Test tracks_for_ids yields None for IDs not found."""
|
|
track = _make_track("490839595", "API Track", "PT3M", "ISRC001", ["a1"])
|
|
artist = _make_artist("a1", "API Artist")
|
|
|
|
self.tidal.api.get_tracks = Mock(
|
|
return_value={
|
|
"data": [track],
|
|
"included": [artist],
|
|
}
|
|
)
|
|
|
|
results = list(
|
|
self.tidal.tracks_for_ids(
|
|
[
|
|
"https://tidal.com/track/490839595",
|
|
"does_not_exist",
|
|
]
|
|
)
|
|
)
|
|
|
|
assert len(results) == 2
|
|
assert results[0] is not None
|
|
assert results[0].title == "API Track"
|
|
assert results[1] is None
|
|
|
|
|
|
class TestAlbumForID(TidalPluginTest):
|
|
"""Tests for album_for_id with mocked API."""
|
|
|
|
def test_album_for_id(self):
|
|
"""Test fetching album by ID via API."""
|
|
track = _make_track("t1", "Album Track", "PT3M30S", "ISRC001", ["a1"])
|
|
album, track_lookup, artist_lookup = _make_album(
|
|
"226495055", "API Album", [track], ["a1"]
|
|
)
|
|
self.tidal.api.get_albums = Mock(
|
|
return_value={
|
|
"data": [album],
|
|
"included": [*artist_lookup.values(), *track_lookup.values()],
|
|
}
|
|
)
|
|
|
|
info = self.tidal.album_for_id("https://tidal.com/album/226495055")
|
|
|
|
assert info is not None
|
|
assert info.album == "API Album"
|
|
assert info.album_id == "226495055"
|
|
assert len(info.tracks) == 1
|
|
assert info.tracks[0].title == "Album Track"
|
|
|
|
def test_album_for_id_not_found(self):
|
|
"""Test album_for_id returns None when not found."""
|
|
self.tidal.api.get_albums = Mock(return_value={"data": []})
|
|
info = self.tidal.album_for_id("https://tidal.com/album/226495055")
|
|
assert info is None
|
|
|
|
info = self.tidal.album_for_id("does_not_exist")
|
|
assert info is None
|
|
|
|
|
|
class TestAlbumsForIDs(TidalPluginTest):
|
|
"""Tests for albums_for_ids with mocked API."""
|
|
|
|
def test_albums_for_ids(self):
|
|
"""Test fetching multiple albums by IDs via API."""
|
|
track1 = _make_track("t1", "Album Track 1", "PT3M", "ISRC001", ["a1"])
|
|
track2 = _make_track("t2", "Album Track 2", "PT4M", "ISRC002", ["a1"])
|
|
album1, track_lookup1, artist_lookup1 = _make_album(
|
|
"226495055", "API Album 1", [track1], ["a1"]
|
|
)
|
|
album2, track_lookup2, artist_lookup2 = _make_album(
|
|
"226495056", "API Album 2", [track2], ["a1"]
|
|
)
|
|
|
|
# Combine lookups to simulate API response
|
|
all_included = [
|
|
*artist_lookup1.values(),
|
|
*artist_lookup2.values(),
|
|
*track_lookup1.values(),
|
|
*track_lookup2.values(),
|
|
]
|
|
|
|
self.tidal.api.get_albums = Mock(
|
|
return_value={
|
|
"data": [album1, album2],
|
|
"included": all_included,
|
|
}
|
|
)
|
|
|
|
results = list(
|
|
self.tidal.albums_for_ids(
|
|
[
|
|
"https://tidal.com/album/226495055",
|
|
"https://tidal.com/album/226495056",
|
|
]
|
|
)
|
|
)
|
|
|
|
self.tidal.api.get_albums.assert_called_once()
|
|
# Note: yields album then None for each ID
|
|
assert len(results) == 2
|
|
assert results[0] is not None
|
|
assert results[0].album == "API Album 1"
|
|
assert results[1] is not None
|
|
assert results[1].album == "API Album 2"
|
|
|
|
def test_albums_for_ids_with_missing(self):
|
|
"""Test albums_for_ids yields None for IDs not found."""
|
|
track = _make_track("t1", "Album Track", "PT3M", "ISRC001", ["a1"])
|
|
album, track_lookup, artist_lookup = _make_album(
|
|
"226495055", "API Album", [track], ["a1"]
|
|
)
|
|
|
|
self.tidal.api.get_albums = Mock(
|
|
return_value={
|
|
"data": [album],
|
|
"included": [*artist_lookup.values(), *track_lookup.values()],
|
|
}
|
|
)
|
|
|
|
results = list(
|
|
self.tidal.albums_for_ids(
|
|
[
|
|
"https://tidal.com/album/226495055",
|
|
"does_not_exist",
|
|
]
|
|
)
|
|
)
|
|
|
|
# yields (album, None) for (found, not_found)
|
|
assert len(results) == 2
|
|
assert results[0] is not None
|
|
assert results[0].album == "API Album"
|
|
assert results[1] is None
|
|
|
|
|
|
class TestCandidates(TidalPluginTest):
|
|
"""Tests for candidates method."""
|
|
|
|
def test_candidates_with_barcode(self):
|
|
"""Test that candidates uses barcode lookup first."""
|
|
track = _make_track("t1", "Album Track", "PT3M", "ISRC001", ["a1"])
|
|
album, track_lookup, artist_lookup = _make_album(
|
|
"al1", "Barcode Album", [track], ["a1"]
|
|
)
|
|
|
|
self.tidal.api.get_albums = Mock(
|
|
return_value={
|
|
"data": [album],
|
|
"included": [*artist_lookup.values(), *track_lookup.values()],
|
|
}
|
|
)
|
|
|
|
items = [Item(barcode="123456")]
|
|
|
|
candidates = list(
|
|
self.tidal.candidates(items, "Artist", "Album", False)
|
|
)
|
|
|
|
self.tidal.api.get_albums.assert_called_once()
|
|
assert len(candidates) == 1
|
|
assert candidates[0].album == "Barcode Album"
|
|
|
|
def test_candidates_with_query_fallback(self):
|
|
"""Test that candidates falls back to query search when no barcode."""
|
|
items = [Item(title="My Song", artist="My Artist", album="My Album")]
|
|
|
|
# Mock search returning album IDs
|
|
self.tidal.api.search_results = Mock(
|
|
return_value={
|
|
"data": {
|
|
"relationships": {
|
|
"albums": {
|
|
"data": [{"id": "al1", "type": "albums"}],
|
|
},
|
|
},
|
|
},
|
|
}
|
|
)
|
|
|
|
# Mock album lookup by ID
|
|
track = _make_track("t1", "Album Track", "PT3M", "ISRC001", ["a1"])
|
|
album, track_lookup, artist_lookup = _make_album(
|
|
"al1", "Query Album", [track], ["a1"]
|
|
)
|
|
self.tidal.api.get_albums = Mock(
|
|
return_value={
|
|
"data": [album],
|
|
"included": [*artist_lookup.values(), *track_lookup.values()],
|
|
}
|
|
)
|
|
|
|
candidates = list(
|
|
self.tidal.candidates(items, "My Artist", "My Album", False)
|
|
)
|
|
|
|
# Should have called search_results
|
|
assert self.tidal.api.search_results.called
|
|
assert len(candidates) == 1
|
|
assert candidates[0].album == "Query Album"
|
|
|
|
|
|
class TestItemCandidates(TidalPluginTest):
|
|
"""Tests for item_candidates method."""
|
|
|
|
def test_item_candidates_with_isrc(self):
|
|
"""Test that item_candidates uses ISRC lookup first."""
|
|
track = _make_track(
|
|
"490839595", "ISRC Track", "PT3M", "ISRC001", ["a1"]
|
|
)
|
|
artist = _make_artist("a1", "ISRC Artist")
|
|
|
|
self.tidal.api.get_tracks = Mock(
|
|
return_value={
|
|
"data": [track],
|
|
"included": [artist],
|
|
}
|
|
)
|
|
|
|
item = Item(isrc="ISRC001")
|
|
|
|
results = list(self.tidal.item_candidates(item, "Artist", "Title"))
|
|
|
|
self.tidal.api.get_tracks.assert_called_once()
|
|
assert len(results) == 1
|
|
assert results[0].title == "ISRC Track"
|
|
|
|
def test_item_candidates_with_query_fallback(self):
|
|
"""Test that item_candidates falls back to query search when no ISRC."""
|
|
item = Item(title="Query Song", artist="Query Artist")
|
|
|
|
self.tidal.api.search_results = Mock(
|
|
return_value={
|
|
"data": {
|
|
"relationships": {
|
|
"tracks": {
|
|
"data": [{"id": "490839595", "type": "tracks"}],
|
|
},
|
|
},
|
|
},
|
|
"included": [
|
|
_make_track(
|
|
"490839595", "Query Track", "PT3M", "ISRC002", ["a1"]
|
|
),
|
|
_make_artist("a1", "Query Artist"),
|
|
],
|
|
}
|
|
)
|
|
|
|
results = list(
|
|
self.tidal.item_candidates(item, "Query Artist", "Query Song")
|
|
)
|
|
|
|
assert self.tidal.api.search_results.called
|
|
assert results[0].title == "Query Track"
|
|
|
|
|
|
class TestStaticHelpers:
|
|
"""Tests for static helper methods."""
|
|
|
|
@pytest.mark.parametrize(
|
|
"attrs, expected",
|
|
[
|
|
(
|
|
{
|
|
"externalLinks": [
|
|
{"href": "https://tidal.com/b/123", "meta": ""}
|
|
]
|
|
},
|
|
"https://tidal.com/b/123",
|
|
),
|
|
({}, None),
|
|
],
|
|
)
|
|
def test_parse_data_url(self, attrs, expected):
|
|
assert TidalPlugin._parse_data_url(attrs) == expected
|
|
|
|
@pytest.mark.parametrize(
|
|
"attrs, expected",
|
|
[
|
|
({"copyright": {"text": "(P) 2024 Tidal"}}, "(P) 2024 Tidal"),
|
|
({}, None),
|
|
],
|
|
)
|
|
def test_parse_label(self, attrs, expected):
|
|
assert TidalPlugin._parse_label(attrs) == expected
|
|
|
|
@pytest.mark.parametrize(
|
|
"attrs, expected",
|
|
[
|
|
({"releaseDate": "2024-01-15"}, (2024, 1, 15)),
|
|
({}, None),
|
|
({"releaseDate": "2024"}, None),
|
|
],
|
|
)
|
|
def test_parse_release_date(self, attrs, expected):
|
|
assert TidalPlugin._parse_release_date(attrs) == expected
|
|
|
|
@pytest.mark.parametrize(
|
|
"duration,expected",
|
|
[
|
|
("PT30S", 30),
|
|
("PT3M30S", 210),
|
|
("PT4M", 240),
|
|
("PT1H", 3600),
|
|
("PT1H30M", 5400),
|
|
],
|
|
)
|
|
def test_duration_conversions(self, duration, expected):
|
|
assert TidalPlugin._duration_to_seconds(duration) == expected
|
|
|
|
def test_duration_invalid_raises(self, caplog):
|
|
with caplog.at_level(logging.WARNING):
|
|
TidalPlugin._duration_to_seconds("invalid")
|
|
assert "Invalid ISO 8601 duration: invalid" in caplog.text
|