269 lines
8.4 KiB
Python
269 lines
8.4 KiB
Python
import pytest
|
|
import time
|
|
import uuid
|
|
from mopidy import models
|
|
|
|
import mopidy_funkwhale.library
|
|
|
|
from . import factories
|
|
|
|
|
|
def test_convert_artist_to_model():
|
|
payload = {"id": 42, "mbid": str(uuid.uuid4()), "name": "Test artist"}
|
|
|
|
result = mopidy_funkwhale.library.convert_to_artist(payload)
|
|
|
|
assert type(result) == models.Artist
|
|
assert result.musicbrainz_id == payload["mbid"]
|
|
assert result.uri == "funkwhale:artists:%s" % (payload["id"],)
|
|
assert result.name == payload["name"]
|
|
assert result.sortname == payload["name"]
|
|
|
|
|
|
def test_convert_album_to_model():
|
|
payload = {
|
|
"id": 3,
|
|
"tracks": [1, 2, 3, 4],
|
|
"mbid": str(uuid.uuid4()),
|
|
"title": "Test album",
|
|
"artist": {"id": 42, "mbid": str(uuid.uuid4()), "name": "Test artist"},
|
|
"release_date": "2017-01-01",
|
|
"cover": {
|
|
"original": "/media/albums/covers/2018/10/03/b4e94b07e-da27-4df4-ae2a-d924a9448544.jpg"
|
|
},
|
|
}
|
|
|
|
result = mopidy_funkwhale.library.convert_to_album(payload)
|
|
|
|
assert type(result) == models.Album
|
|
assert result.musicbrainz_id == payload["mbid"]
|
|
assert result.uri == "funkwhale:albums:%s" % (payload["id"],)
|
|
assert result.name == payload["title"]
|
|
assert result.date == payload["release_date"]
|
|
assert result.num_tracks == len(payload["tracks"])
|
|
assert result.artists == frozenset(
|
|
[mopidy_funkwhale.library.convert_to_artist(payload["artist"])]
|
|
)
|
|
|
|
|
|
def test_convert_track_to_model():
|
|
payload = {
|
|
"id": 2,
|
|
"title": "Test track",
|
|
"mbid": str(uuid.uuid4()),
|
|
"creation_date": "2017-01-01",
|
|
"position": 12,
|
|
"artist": {"id": 43, "mbid": str(uuid.uuid4()), "name": "Test artist 2"},
|
|
"album": {
|
|
"id": 3,
|
|
"tracks": [1, 2, 3, 4],
|
|
"mbid": str(uuid.uuid4()),
|
|
"title": "Test album",
|
|
"artist": {"id": 42, "mbid": str(uuid.uuid4()), "name": "Test artist"},
|
|
"release_date": "2017-01-01",
|
|
"cover": {
|
|
"original": "/media/albums/covers/2018/10/03/b4e94b07e-da27-4df4-ae2a-d924a9448544.jpg"
|
|
},
|
|
},
|
|
"uploads": [{"bitrate": 128000, "duration": 120}],
|
|
}
|
|
|
|
result = mopidy_funkwhale.library.convert_to_track(payload)
|
|
|
|
assert type(result) == models.Track
|
|
assert result.musicbrainz_id == payload["mbid"]
|
|
assert result.uri == "funkwhale:tracks:%s" % (payload["id"],)
|
|
assert result.name == payload["title"]
|
|
assert result.date == payload["album"]["release_date"]
|
|
assert result.length == payload["uploads"][0]["duration"] * 1000
|
|
assert result.bitrate == payload["uploads"][0]["bitrate"] / 1000
|
|
|
|
assert result.album == mopidy_funkwhale.library.convert_to_album(payload["album"])
|
|
assert result.artists == frozenset(
|
|
[mopidy_funkwhale.library.convert_to_artist(payload["artist"])]
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"uri, expected",
|
|
[
|
|
("funkwhale:albums:42", ("album", 42)),
|
|
("funkwhale:tracks:42", ("track", 42)),
|
|
("funkwhale:artists:42", ("artist", 42)),
|
|
],
|
|
)
|
|
def test_parse_uri(uri, expected):
|
|
assert mopidy_funkwhale.library.parse_uri(uri) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("type", ["track", "album", "artist"])
|
|
def test_to_ref(type):
|
|
obj = getattr(models, type.capitalize())(uri="hello:world", name="Hello")
|
|
expected = getattr(models.Ref, type)(uri=obj.uri, name=obj.name)
|
|
assert mopidy_funkwhale.library.to_ref(obj) == expected
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"path, expected_handler,remaining",
|
|
[
|
|
("funkwhale:directory:favorites", "browse_favorites", []),
|
|
("funkwhale:directory:favorites:by-date", "browse_favorites", ["by-date"]),
|
|
],
|
|
)
|
|
def test_browse_routing(library, path, expected_handler, mocker, remaining):
|
|
handler = mocker.patch.object(
|
|
library, expected_handler, return_value=("test", False), autospec=True
|
|
)
|
|
|
|
assert library.browse(path) == "test"
|
|
handler.assert_called_once_with(remaining)
|
|
|
|
|
|
def test_browse_favorites_root(library):
|
|
expected = (
|
|
[
|
|
models.Ref.directory(
|
|
uri="funkwhale:directory:favorites:recent", name="Recent"
|
|
),
|
|
# models.Ref.directory(
|
|
# uri="funkwhale:directory:favorites:by-artist", name="By artist"
|
|
# ),
|
|
],
|
|
False,
|
|
)
|
|
assert library.browse_favorites([]) == expected
|
|
|
|
|
|
def test_browse_favorites_recent(library, client, requests_mock):
|
|
track = factories.TrackJSONFactory()
|
|
url = (
|
|
client.session.url_base
|
|
+ "tracks/?favorites=true&page_size=50&&ordering=-creation_date"
|
|
)
|
|
requests_mock.get(url, json={"results": [track]})
|
|
|
|
expected = [mopidy_funkwhale.library.convert_to_track(track, ref=True)], True
|
|
result = library.browse_favorites(["recent"])
|
|
|
|
assert result == expected
|
|
|
|
|
|
def test_browse_artists_root(library):
|
|
expected = (
|
|
[
|
|
models.Ref.directory(
|
|
uri="funkwhale:directory:artists:recent", name="Recent"
|
|
),
|
|
models.Ref.directory(
|
|
uri="funkwhale:directory:artists:by-name", name="By name"
|
|
),
|
|
models.Ref.directory(
|
|
uri="funkwhale:directory:artists:scope-me", name="Own Content"
|
|
),
|
|
],
|
|
False,
|
|
)
|
|
assert library.browse_artists([]) == expected
|
|
|
|
|
|
def test_browse_artists_recent(client, library, requests_mock):
|
|
artist1 = factories.ArtistJSONFactory()
|
|
artist2 = factories.ArtistJSONFactory()
|
|
url = (
|
|
client.session.url_base
|
|
+ "artists/?page_size=50&ordering=-creation_date&playable=true"
|
|
)
|
|
requests_mock.get(url, json={"results": [artist1, artist2]})
|
|
uri_prefix = "funkwhale:directory:artists:recent"
|
|
|
|
expected = (
|
|
[
|
|
mopidy_funkwhale.library.convert_to_artist(
|
|
artist1, uri_prefix=uri_prefix, ref=True
|
|
),
|
|
mopidy_funkwhale.library.convert_to_artist(
|
|
artist2, uri_prefix=uri_prefix, ref=True
|
|
),
|
|
],
|
|
True,
|
|
)
|
|
assert library.browse_artists(["recent"]) == expected
|
|
|
|
|
|
def test_browse_artists_albums(client, library, requests_mock):
|
|
album1 = factories.AlbumJSONFactory()
|
|
album2 = factories.AlbumJSONFactory(artist=album1["artist"])
|
|
url = (
|
|
client.session.url_base
|
|
+ "albums/?ordering=title&page_size=50&playable=true&artist=%s"
|
|
% album1["artist"]["id"]
|
|
)
|
|
requests_mock.get(url, json={"results": [album1, album2]})
|
|
uri_prefix = "funkwhale:directory:artists:by-name:%s" % album1["artist"]["id"]
|
|
expected = (
|
|
[
|
|
mopidy_funkwhale.library.convert_to_album(
|
|
album1, uri_prefix=uri_prefix, ref=True
|
|
),
|
|
mopidy_funkwhale.library.convert_to_album(
|
|
album2, uri_prefix=uri_prefix, ref=True
|
|
),
|
|
],
|
|
True,
|
|
)
|
|
assert library.browse_artists(["by-name", album1["artist"]["id"]]) == expected
|
|
|
|
|
|
def test_browse_artists_album_single(client, library, requests_mock):
|
|
track = factories.TrackJSONFactory()
|
|
url = (
|
|
client.session.url_base
|
|
+ "tracks/?page_size=50&ordering=position&playable=true&album="
|
|
+ str(track["album"]["id"])
|
|
)
|
|
requests_mock.get(url, json={"results": [track]})
|
|
expected = ([mopidy_funkwhale.library.convert_to_track(track, ref=True)], True)
|
|
assert (
|
|
library.browse_artists(
|
|
["by-name", track["album"]["artist"]["id"], track["album"]["id"]]
|
|
)
|
|
== expected
|
|
)
|
|
|
|
|
|
def test_cache_set():
|
|
cache = mopidy_funkwhale.library.Cache()
|
|
cache.set("hello:world", "value")
|
|
assert cache["hello:world"][0] < time.time()
|
|
assert cache["hello:world"][1] == "value"
|
|
|
|
|
|
def test_cache_get():
|
|
cache = mopidy_funkwhale.library.Cache()
|
|
cache["hello:world"] = (time.time(), "value")
|
|
assert cache.get("hello:world") == "value"
|
|
|
|
|
|
def test_cache_key_too_old():
|
|
cache = mopidy_funkwhale.library.Cache(max_age=60)
|
|
t = time.time() - 60
|
|
cache["hello:world"] = (t, "value")
|
|
assert cache.get("hello:world") is None
|
|
assert "hello:world" not in cache
|
|
|
|
|
|
def test_lookup_from_cache(library):
|
|
track = object()
|
|
library.cache.set("funkwhale:artists:42", track)
|
|
|
|
result = library.lookup("funkwhale:artists:42")
|
|
assert result == [track]
|
|
|
|
|
|
def test_lookup_from_cache_iterable(library):
|
|
track = [object()]
|
|
library.cache.set("funkwhale:artists:42", track)
|
|
|
|
result = library.lookup("funkwhale:artists:42")
|
|
assert result == track
|