Fixed #54: Now use pytest everywhere \o/

api/tests/music/test_api.py

+import json
+import pytest
+from django.urls import reverse
+
+from funkwhale_api.music import models
+from funkwhale_api.musicbrainz import api
+from funkwhale_api.music import serializers
+
+from . import data as api_data
+
+
+def test_can_submit_youtube_url_for_track_import(mocker, superuser_client):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.artists.get',
+        return_value=api_data.artists['get']['adhesive_wombat'])
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.releases.get',
+        return_value=api_data.albums['get']['marsupial'])
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.recordings.get',
+        return_value=api_data.tracks['get']['8bitadventures'])
+    mocker.patch(
+        'funkwhale_api.music.models.TrackFile.download_file',
+        return_value=None)
+    mbid = '9968a9d6-8d92-4051-8f76-674e157b6eed'
+    video_id = 'tPEE9ZwTmy0'
+    url = reverse('api:v1:submit-single')
+    response = superuser_client.post(
+        url,
+        {'import_url': 'https://www.youtube.com/watch?v={0}'.format(video_id),
+         'mbid': mbid})
+    track = models.Track.objects.get(mbid=mbid)
+    assert track.artist.name == 'Adhesive Wombat'
+    assert track.album.title == 'Marsupial Madness'
+
+
+def test_import_creates_an_import_with_correct_data(superuser_client, settings):
+    mbid = '9968a9d6-8d92-4051-8f76-674e157b6eed'
+    video_id = 'tPEE9ZwTmy0'
+    url = reverse('api:v1:submit-single')
+    settings.CELERY_ALWAYS_EAGER = False
+    response = superuser_client.post(
+        url,
+        {'import_url': 'https://www.youtube.com/watch?v={0}'.format(video_id),
+         'mbid': mbid})
+
+    batch = models.ImportBatch.objects.latest('id')
+    assert batch.jobs.count() == 1
+    assert batch.submitted_by == superuser_client.user
+    assert batch.status == 'pending'
+    job = batch.jobs.first()
+    assert str(job.mbid) == mbid
+    assert job.status == 'pending'
+    assert job.source == 'https://www.youtube.com/watch?v={0}'.format(video_id)
+
+
+def test_can_import_whole_album(mocker, superuser_client, settings):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.artists.get',
+        return_value=api_data.artists['get']['soad'])
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.images.get_front',
+        return_value=b'')
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.releases.get',
+        return_value=api_data.albums['get_with_includes']['hypnotize'])
+    payload = {
+        'releaseId': '47ae093f-1607-49a3-be11-a15d335ccc94',
+        'tracks': [
+            {
+            'mbid': '1968a9d6-8d92-4051-8f76-674e157b6eed',
+            'source': 'https://www.youtube.com/watch?v=1111111111',
+            },
+            {
+            'mbid': '2968a9d6-8d92-4051-8f76-674e157b6eed',
+            'source': 'https://www.youtube.com/watch?v=2222222222',
+            },
+            {
+            'mbid': '3968a9d6-8d92-4051-8f76-674e157b6eed',
+            'source': 'https://www.youtube.com/watch?v=3333333333',
+            },
+        ]
+    }
+    url = reverse('api:v1:submit-album')
+    settings.CELERY_ALWAYS_EAGER = False
+    response = superuser_client.post(
+        url, json.dumps(payload), content_type="application/json")
+
+    batch = models.ImportBatch.objects.latest('id')
+    assert batch.jobs.count() == 3
+    assert batch.submitted_by == superuser_client.user
+    assert batch.status == 'pending'
+
+    album = models.Album.objects.latest('id')
+    assert str(album.mbid) == '47ae093f-1607-49a3-be11-a15d335ccc94'
+    medium_data = api_data.albums['get_with_includes']['hypnotize']['release']['medium-list'][0]
+    assert int(medium_data['track-count']) == album.tracks.all().count()
+
+    for track in medium_data['track-list']:
+        instance = models.Track.objects.get(mbid=track['recording']['id'])
+        assert instance.title == track['recording']['title']
+        assert instance.position == int(track['position'])
+        assert instance.title == track['recording']['title']
+
+    for row in payload['tracks']:
+        job = models.ImportJob.objects.get(mbid=row['mbid'])
+        assert str(job.mbid) == row['mbid']
+        assert job.status == 'pending'
+        assert job.source == row['source']
+
+
+def test_can_import_whole_artist(mocker, superuser_client, settings):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.artists.get',
+        return_value=api_data.artists['get']['soad'])
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.images.get_front',
+        return_value=b'')
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.releases.get',
+        return_value=api_data.albums['get_with_includes']['hypnotize'])
+    payload = {
+        'artistId': 'mbid',
+        'albums': [
+            {
+                'releaseId': '47ae093f-1607-49a3-be11-a15d335ccc94',
+                'tracks': [
+                    {
+                    'mbid': '1968a9d6-8d92-4051-8f76-674e157b6eed',
+                    'source': 'https://www.youtube.com/watch?v=1111111111',
+                    },
+                    {
+                    'mbid': '2968a9d6-8d92-4051-8f76-674e157b6eed',
+                    'source': 'https://www.youtube.com/watch?v=2222222222',
+                    },
+                    {
+                    'mbid': '3968a9d6-8d92-4051-8f76-674e157b6eed',
+                    'source': 'https://www.youtube.com/watch?v=3333333333',
+                    },
+                ]
+            }
+        ]
+    }
+    url = reverse('api:v1:submit-artist')
+    settings.CELERY_ALWAYS_EAGER = False
+    response = superuser_client.post(
+        url, json.dumps(payload), content_type="application/json")
+
+    batch = models.ImportBatch.objects.latest('id')
+    assert batch.jobs.count() == 3
+    assert batch.submitted_by == superuser_client.user
+    assert batch.status == 'pending'
+
+    album = models.Album.objects.latest('id')
+    assert str(album.mbid) == '47ae093f-1607-49a3-be11-a15d335ccc94'
+    medium_data = api_data.albums['get_with_includes']['hypnotize']['release']['medium-list'][0]
+    assert int(medium_data['track-count']) == album.tracks.all().count()
+
+    for track in medium_data['track-list']:
+        instance = models.Track.objects.get(mbid=track['recording']['id'])
+        assert instance.title == track['recording']['title']
+        assert instance.position == int(track['position'])
+        assert instance.title == track['recording']['title']
+
+    for row in payload['albums'][0]['tracks']:
+        job = models.ImportJob.objects.get(mbid=row['mbid'])
+        assert str(job.mbid) == row['mbid']
+        assert job.status == 'pending'
+        assert job.source == row['source']
+
+
+def test_user_can_query_api_for_his_own_batches(client, factories):
+    user1 = factories['users.SuperUser']()
+    user2 = factories['users.SuperUser']()
+
+    job = factories['music.ImportJob'](batch__submitted_by=user1)
+    url = reverse('api:v1:import-batches-list')
+
+    client.login(username=user2.username, password='test')
+    response2 = client.get(url)
+    results = json.loads(response2.content.decode('utf-8'))
+    assert results['count'] == 0
+    client.logout()
+
+    client.login(username=user1.username, password='test')
+    response1 = client.get(url)
+    results = json.loads(response1.content.decode('utf-8'))
+    assert results['count'] == 1
+    assert results['results'][0]['jobs'][0]['mbid'] == job.mbid
+
+
+def test_can_search_artist(factories, client):
+    artist1 = factories['music.Artist']()
+    artist2 = factories['music.Artist']()
+    expected = [serializers.ArtistSerializerNested(artist1).data]
+    url = reverse('api:v1:artists-search')
+    response = client.get(url, {'query': artist1.name})
+    assert json.loads(response.content.decode('utf-8')) == expected
+
+
+def test_can_search_artist_by_name_start(factories, client):
+    artist1 = factories['music.Artist'](name='alpha')
+    artist2 = factories['music.Artist'](name='beta')
+    expected = {
+        'next': None,
+        'previous': None,
+        'count': 1,
+        'results': [serializers.ArtistSerializerNested(artist1).data]
+    }
+    url = reverse('api:v1:artists-list')
+    response = client.get(url, {'name__startswith': 'a'})
+
+    assert expected == json.loads(response.content.decode('utf-8'))
+
+
+def test_can_search_tracks(factories, client):
+    track1 = factories['music.Track'](title="test track 1")
+    track2 = factories['music.Track']()
+    query = 'test track 1'
+    expected = [serializers.TrackSerializerNested(track1).data]
+    url = reverse('api:v1:tracks-search')
+    response = client.get(url, {'query': query})
+
+    assert expected == json.loads(response.content.decode('utf-8'))
+
+
+@pytest.mark.parametrize('route,method', [
+    ('api:v1:tags-list', 'get'),
+    ('api:v1:tracks-list', 'get'),
+    ('api:v1:artists-list', 'get'),
+    ('api:v1:albums-list', 'get'),
+])
+def test_can_restrict_api_views_to_authenticated_users(db, route, method, settings, client):
+    url = reverse(route)
+    settings.API_AUTHENTICATION_REQUIRED = True
+    response = getattr(client, method)(url)
+    assert response.status_code == 401
+
+
+def test_track_file_url_is_restricted_to_authenticated_users(client, factories, settings):
+    settings.API_AUTHENTICATION_REQUIRED = True
+    f = factories['music.TrackFile']()
+    assert f.audio_file is not None
+    url = f.path
+    response = client.get(url)
+    assert response.status_code == 401
+
+    user = factories['users.SuperUser']()
+    client.login(username=user.username, password='test')
+    response = client.get(url)
+
+    assert response.status_code == 200
+    assert response['X-Accel-Redirect'] == '/_protected{}'.format(f.audio_file.url)

api/tests/music/test_lyrics.py

+import json
+from django.urls import reverse
+
+from funkwhale_api.music import models
+from funkwhale_api.musicbrainz import api
+from funkwhale_api.music import serializers
+from funkwhale_api.music import lyrics as lyrics_utils
+
+from .mocking import lyricswiki
+from . import data as api_data
+
+
+
+def test_works_import_lyrics_if_any(mocker, factories):
+    mocker.patch(
+        'funkwhale_api.music.lyrics._get_html',
+        return_value=lyricswiki.content)
+    lyrics = factories['music.Lyrics'](
+        url='http://lyrics.wikia.com/System_Of_A_Down:Chop_Suey!')
+
+    lyrics.fetch_content()
+    self.assertIn(
+        'Grab a brush and put on a little makeup',
+        lyrics.content,
+    )
+
+
+def test_clean_content():
+    c = """<div class="lyricbox">Hello<br /><script>alert('hello');</script>Is it me you're looking for?<br /></div>"""
+    d = lyrics_utils.extract_content(c)
+    d = lyrics_utils.clean_content(d)
+
+    expected = """Hello
+Is it me you're looking for?
+"""
+    assert d == expected
+
+
+def test_markdown_rendering(factories):
+    content = """Hello
+Is it me you're looking for?"""
+
+    l = factories['music.Lyrics'](content=content)
+
+    expected = "<p>Hello<br />\nIs it me you're looking for?</p>"
+    assert expected == l.content_rendered
+
+
+def test_works_import_lyrics_if_any(mocker, factories, logged_in_client):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.works.get',
+        return_value=api_data.works['get']['chop_suey'])
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.recordings.get',
+        return_value=api_data.tracks['get']['chop_suey'])
+    mocker.patch(
+        'funkwhale_api.music.lyrics._get_html',
+        return_value=lyricswiki.content)
+    track = factories['music.Track'](
+        work=None,
+        mbid='07ca77cf-f513-4e9c-b190-d7e24bbad448')
+
+    url = reverse('api:v1:tracks-lyrics', kwargs={'pk': track.pk})
+    response = logged_in_client.get(url)
+
+    assert response.status_code == 200
+
+    track.refresh_from_db()
+    lyrics = models.Lyrics.objects.latest('id')
+    work = models.Work.objects.latest('id')
+
+    assert track.work == work
+    assert lyrics.work == work

api/tests/music/test_metadata.py

+import datetime
+import os
+import pytest
+
+from funkwhale_api.music import metadata
+
+DATA_DIR = os.path.dirname(os.path.abspath(__file__))
+
+
+@pytest.mark.parametrize('field,value', [
+    ('title', 'Peer Gynt Suite no. 1, op. 46: I. Morning'),
+    ('artist', 'Edvard Grieg'),
+    ('album', 'Peer Gynt Suite no. 1, op. 46'),
+    ('date', datetime.date(2012, 8, 15)),
+    ('track_number', 1),
+    ('musicbrainz_albumid', 'a766da8b-8336-47aa-a3ee-371cc41ccc75'),
+    ('musicbrainz_recordingid', 'bd21ac48-46d8-4e78-925f-d9cc2a294656'),
+    ('musicbrainz_artistid', '013c8e5b-d72a-4cd3-8dee-6c64d6125823'),
+])
+def test_can_get_metadata_from_ogg_file(field, value):
+    path = os.path.join(DATA_DIR, 'test.ogg')
+    data = metadata.Metadata(path)
+
+    assert data.get(field) == value
+
+
+@pytest.mark.parametrize('field,value', [
+    ('title', 'Bend'),
+    ('artist', 'Binärpilot'),
+    ('album', 'You Can\'t Stop Da Funk'),
+    ('date', datetime.date(2006, 2, 7)),
+    ('track_number', 1),
+    ('musicbrainz_albumid', 'ce40cdb1-a562-4fd8-a269-9269f98d4124'),
+    ('musicbrainz_recordingid', 'f269d497-1cc0-4ae4-a0c4-157ec7d73fcb'),
+    ('musicbrainz_artistid', '9c6bddde-6228-4d9f-ad0d-03f6fcb19e13'),
+])
+def test_can_get_metadata_from_id3_mp3_file(field, value):
+    path = os.path.join(DATA_DIR, 'test.mp3')
+    data = metadata.Metadata(path)
+
+    assert data.get(field) == value

api/funkwhale_api/music/tests/test_models.py → api/tests/music/test_models.py

@@ -2,16 +2,14 @@ import pytest
 
 from funkwhale_api.music import models
 from funkwhale_api.music import importers
-from . import factories
 
 
-def test_can_store_release_group_id_on_album(db):
-    album = factories.AlbumFactory()
+def test_can_store_release_group_id_on_album(factories):
+    album = factories['music.Album']()
     assert album.release_group_id is not None
 
 
-def test_import_album_stores_release_group(db):
-
+def test_import_album_stores_release_group(factories):
     album_data = {
         "artist-credit": [
             {
@@ -31,7 +29,7 @@ def test_import_album_stores_release_group(db):
         "title": "Marsupial Madness",
         'release-group': {'id': '447b4979-2178-405c-bfe6-46bf0b09e6c7'}
     }
-    artist = factories.ArtistFactory(
+    artist = factories['music.Artist'](
         mbid=album_data['artist-credit'][0]['artist']['id']
     )
     cleaned_data = models.Album.clean_musicbrainz_data(album_data)
@@ -41,9 +39,9 @@ def test_import_album_stores_release_group(db):
     assert album.artist == artist
 
 
-def test_import_job_is_bound_to_track_file(db, mocker):
-    track = factories.TrackFactory()
-    job = factories.ImportJobFactory(mbid=track.mbid)
+def test_import_job_is_bound_to_track_file(factories, mocker):
+    track = factories['music.Track']()
+    job = factories['music.ImportJob'](mbid=track.mbid)
 
     mocker.patch('funkwhale_api.music.models.TrackFile.download_file')
     job.run()

api/tests/music/test_music.py

+import pytest
+from funkwhale_api.music import models
+import datetime
+
+from . import data as api_data
+from .cover import binary_data
+
+
+def test_can_create_artist_from_api(mocker, db):
+    mocker.patch(
+        'musicbrainzngs.search_artists',
+        return_value=api_data.artists['search']['adhesive_wombat'])
+    artist = models.Artist.create_from_api(query="Adhesive wombat")
+    data = models.Artist.api.search(query='Adhesive wombat')['artist-list'][0]
+
+    assert int(data['ext:score']), 100
+    assert data['id'], '62c3befb-6366-4585-b256-809472333801'
+    assert artist.mbid, data['id']
+    assert artist.name, 'Adhesive Wombat'
+
+
+def test_can_create_album_from_api(mocker, db):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.releases.search',
+        return_value=api_data.albums['search']['hypnotize'])
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.artists.get',
+        return_value=api_data.artists['get']['soad'])
+    album = models.Album.create_from_api(query="Hypnotize", artist='system of a down', type='album')
+    data = models.Album.api.search(query='Hypnotize', artist='system of a down', type='album')['release-list'][0]
+
+    assert album.mbid, data['id']
+    assert album.title, 'Hypnotize'
+    with pytest.raises(ValueError):
+        assert album.cover.path is not None
+    assert album.release_date, datetime.date(2005, 1, 1)
+    assert album.artist.name, 'System of a Down'
+    assert album.artist.mbid, data['artist-credit'][0]['artist']['id']
+
+
+def test_can_create_track_from_api(mocker, db):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.artists.get',
+        return_value=api_data.artists['get']['adhesive_wombat'])
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.releases.get',
+        return_value=api_data.albums['get']['marsupial'])
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.recordings.search',
+        return_value=api_data.tracks['search']['8bitadventures'])
+    track = models.Track.create_from_api(query="8-bit adventure")
+    data = models.Track.api.search(query='8-bit adventure')['recording-list'][0]
+    assert int(data['ext:score']) == 100
+    assert data['id'] == '9968a9d6-8d92-4051-8f76-674e157b6eed'
+    assert track.mbid == data['id']
+    assert track.artist.pk is not None
+    assert str(track.artist.mbid) == '62c3befb-6366-4585-b256-809472333801'
+    assert track.artist.name == 'Adhesive Wombat'
+    assert str(track.album.mbid) == 'a50d2a81-2a50-484d-9cb4-b9f6833f583e'
+    assert track.album.title == 'Marsupial Madness'
+
+
+def test_can_create_track_from_api_with_corresponding_tags(mocker, db):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.artists.get',
+        return_value=api_data.artists['get']['adhesive_wombat'])
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.releases.get',
+        return_value=api_data.albums['get']['marsupial'])
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.recordings.get',
+        return_value=api_data.tracks['get']['8bitadventures'])
+    track = models.Track.create_from_api(id='9968a9d6-8d92-4051-8f76-674e157b6eed')
+    expected_tags = ['techno', 'good-music']
+    track_tags = [tag.slug for tag in track.tags.all()]
+    for tag in expected_tags:
+        assert tag in track_tags
+
+
+def test_can_get_or_create_track_from_api(mocker, db):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.artists.get',
+        return_value=api_data.artists['get']['adhesive_wombat'])
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.releases.get',
+        return_value=api_data.albums['get']['marsupial'])
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.recordings.search',
+        return_value=api_data.tracks['search']['8bitadventures'])
+    track = models.Track.create_from_api(query="8-bit adventure")
+    data = models.Track.api.search(query='8-bit adventure')['recording-list'][0]
+    assert int(data['ext:score']) == 100
+    assert data['id'] == '9968a9d6-8d92-4051-8f76-674e157b6eed'
+    assert track.mbid == data['id']
+    assert track.artist.pk is not None
+    assert str(track.artist.mbid) == '62c3befb-6366-4585-b256-809472333801'
+    assert track.artist.name == 'Adhesive Wombat'
+
+    track2, created = models.Track.get_or_create_from_api(mbid=data['id'])
+    assert not created
+    assert track == track2
+
+
+def test_album_tags_deduced_from_tracks_tags(factories, django_assert_num_queries):
+    tag = factories['taggit.Tag']()
+    album = factories['music.Album']()
+    tracks = factories['music.Track'].create_batch(
+        5, album=album, tags=[tag])
+
+    album = models.Album.objects.prefetch_related('tracks__tags').get(pk=album.pk)
+
+    with django_assert_num_queries(0):
+        assert tag in album.tags
+
+
+def test_artist_tags_deduced_from_album_tags(factories, django_assert_num_queries):
+    tag = factories['taggit.Tag']()
+    album = factories['music.Album']()
+    artist = album.artist
+    tracks = factories['music.Track'].create_batch(
+        5, album=album, tags=[tag])
+
+    artist = models.Artist.objects.prefetch_related('albums__tracks__tags').get(pk=artist.pk)
+
+    with django_assert_num_queries(0):
+        assert tag in artist.tags
+
+
+def test_can_download_image_file_for_album(mocker, factories):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.images.get_front',
+        return_value=binary_data)
+    # client._api.get_image_front('55ea4f82-b42b-423e-a0e5-290ccdf443ed')
+    album = factories['music.Album'](mbid='55ea4f82-b42b-423e-a0e5-290ccdf443ed')
+    album.get_image()
+    album.save()
+
+    assert album.cover.file.read() == binary_data

api/tests/music/test_works.py

+import json
+from django.urls import reverse
+
+from funkwhale_api.music import models
+from funkwhale_api.musicbrainz import api
+from funkwhale_api.music import serializers
+
+from . import data as api_data
+
+
+def test_can_import_work(factories, mocker):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.works.get',
+        return_value=api_data.works['get']['chop_suey'])
+    recording = factories['music.Track'](
+        mbid='07ca77cf-f513-4e9c-b190-d7e24bbad448')
+    mbid = 'e2ecabc4-1b9d-30b2-8f30-3596ec423dc5'
+    work = models.Work.create_from_api(id=mbid)
+
+    assert work.title == 'Chop Suey!'
+    assert work.nature == 'song'
+    assert work.language == 'eng'
+    assert work.mbid == mbid
+
+    # a imported work should also be linked to corresponding recordings
+
+    recording.refresh_from_db()
+    assert recording.work == work
+
+
+def test_can_get_work_from_recording(factories, mocker):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.works.get',
+        return_value=api_data.works['get']['chop_suey'])
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.recordings.get',
+        return_value=api_data.tracks['get']['chop_suey'])
+    recording = factories['music.Track'](
+        work=None,
+        mbid='07ca77cf-f513-4e9c-b190-d7e24bbad448')
+    mbid = 'e2ecabc4-1b9d-30b2-8f30-3596ec423dc5'
+
+    assert recording.work == None
+
+    work = recording.get_work()
+
+    assert work.title == 'Chop Suey!'
+    assert work.nature == 'song'
+    assert work.language == 'eng'
+    assert work.mbid == mbid
+
+    recording.refresh_from_db()
+    assert recording.work == work
+
+
+def test_works_import_lyrics_if_any(db, mocker):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.works.get',
+        return_value=api_data.works['get']['chop_suey'])
+    mbid = 'e2ecabc4-1b9d-30b2-8f30-3596ec423dc5'
+    work = models.Work.create_from_api(id=mbid)
+
+    lyrics = models.Lyrics.objects.latest('id')
+    assert lyrics.work == work
+    assert lyrics.url == 'http://lyrics.wikia.com/System_Of_A_Down:Chop_Suey!'

api/tests/musicbrainz/test_api.py

+import json
+from django.urls import reverse
+
+from funkwhale_api.musicbrainz import api
+from . import data as api_data
+
+
+
+def test_can_search_recording_in_musicbrainz_api(db, mocker, client):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.recordings.search',
+        return_value=api_data.recordings['search']['brontide matador'])
+    query = 'brontide matador'
+    url = reverse('api:v1:providers:musicbrainz:search-recordings')
+    expected = api_data.recordings['search']['brontide matador']
+    response = client.get(url, data={'query': query})
+
+    assert expected == json.loads(response.content.decode('utf-8'))
+
+
+def test_can_search_release_in_musicbrainz_api(db, mocker, client):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.releases.search',
+        return_value=api_data.releases['search']['brontide matador'])
+    query = 'brontide matador'
+    url = reverse('api:v1:providers:musicbrainz:search-releases')
+    expected = api_data.releases['search']['brontide matador']
+    response = client.get(url, data={'query': query})
+
+    assert expected == json.loads(response.content.decode('utf-8'))
+
+
+def test_can_search_artists_in_musicbrainz_api(db, mocker, client):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.artists.search',
+        return_value=api_data.artists['search']['lost fingers'])
+    query = 'lost fingers'
+    url = reverse('api:v1:providers:musicbrainz:search-artists')
+    expected = api_data.artists['search']['lost fingers']
+    response = client.get(url, data={'query': query})
+
+    assert expected == json.loads(response.content.decode('utf-8'))
+
+
+def test_can_get_artist_in_musicbrainz_api(db, mocker, client):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.artists.get',
+        return_value=api_data.artists['get']['lost fingers'])
+    uuid = 'ac16bbc0-aded-4477-a3c3-1d81693d58c9'
+    url = reverse('api:v1:providers:musicbrainz:artist-detail', kwargs={
+        'uuid': uuid,
+    })
+    response = client.get(url)
+    expected = api_data.artists['get']['lost fingers']
+
+    assert expected == json.loads(response.content.decode('utf-8'))
+
+
+def test_can_broswe_release_group_using_musicbrainz_api(db, mocker, client):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.release_groups.browse',
+        return_value=api_data.release_groups['browse']['lost fingers'])
+    uuid = 'ac16bbc0-aded-4477-a3c3-1d81693d58c9'
+    url = reverse(
+        'api:v1:providers:musicbrainz:release-group-browse',
+        kwargs={
+            'artist_uuid': uuid,
+        }
+    )
+    response = client.get(url)
+    expected = api_data.release_groups['browse']['lost fingers']
+
+    assert expected == json.loads(response.content.decode('utf-8'))
+
+
+def test_can_broswe_releases_using_musicbrainz_api(db, mocker, client):
+    mocker.patch(
+        'funkwhale_api.musicbrainz.api.releases.browse',
+        return_value=api_data.releases['browse']['Lost in the 80s'])
+    uuid = 'f04ed607-11b7-3843-957e-503ecdd485d1'
+    url = reverse(
+        'api:v1:providers:musicbrainz:release-browse',
+        kwargs={
+            'release_group_uuid': uuid,
+        }
+    )
+    response = client.get(url)
+    expected = api_data.releases['browse']['Lost in the 80s']
+
+    assert expected == json.loads(response.content.decode('utf-8'))

api/tests/musicbrainz/test_cache.py

+from funkwhale_api.musicbrainz import client
+
+
+def test_can_search_recording_in_musicbrainz_api(mocker):
+    r = {'hello': 'world'}
+    m = mocker.patch(
+        'funkwhale_api.musicbrainz.client._api.search_artists',
+        return_value=r)
+    assert client.api.artists.search('test') == r
+    # now call from cache
+    assert client.api.artists.search('test') == r
+    assert client.api.artists.search('test') == r
+    assert m.call_count == 1

api/tests/test_disk_import.py

+import os
+import datetime
+
+from funkwhale_api.providers.audiofile import tasks
+
+DATA_DIR = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)),
+    'files'
+)
+
+
+def test_can_import_single_audio_file(db, mocker):
+    metadata = {
+        'artist': ['Test artist'],
+        'album': ['Test album'],
+        'title': ['Test track'],
+        'TRACKNUMBER': ['4'],
+        'date': ['2012-08-15'],
+        'musicbrainz_albumid': ['a766da8b-8336-47aa-a3ee-371cc41ccc75'],
+        'musicbrainz_trackid': ['bd21ac48-46d8-4e78-925f-d9cc2a294656'],
+        'musicbrainz_artistid': ['013c8e5b-d72a-4cd3-8dee-6c64d6125823'],
+    }
+
+    m1 = mocker.patch('mutagen.File', return_value=metadata)
+    m2 = mocker.patch(
+        'funkwhale_api.music.metadata.Metadata.get_file_type',
+        return_value='OggVorbis',
+    )
+    track_file = tasks.from_path(os.path.join(DATA_DIR, 'dummy_file.ogg'))
+    track = track_file.track
+
+    assert track.title == metadata['title'][0]
+    assert track.mbid == metadata['musicbrainz_trackid'][0]
+    assert track.position == 4
+    assert track.album.title == metadata['album'][0]
+    assert track.album.mbid == metadata['musicbrainz_albumid'][0]
+    assert track.album.release_date == datetime.date(2012, 8, 15)
+    assert track.artist.name == metadata['artist'][0]
+    assert track.artist.mbid == metadata['musicbrainz_artistid'][0]

api/tests/test_downloader.py

+import os
+
+from funkwhale_api import downloader
+
+
+def test_can_download_audio_from_youtube_url_to_vorbis(tmpdir):
+    data = downloader.download(
+        'https://www.youtube.com/watch?v=tPEE9ZwTmy0',
+        target_directory=tmpdir)
+    assert data['audio_file_path'] == os.path.join(tmpdir, 'tPEE9ZwTmy0.ogg')
+    assert os.path.exists(data['audio_file_path'])

api/tests/test_favorites.py

+import json
+import pytest
+from django.urls import reverse
+
+from funkwhale_api.music.models import Track, Artist
+from funkwhale_api.favorites.models import TrackFavorite
+
+
+
+def test_user_can_add_favorite(factories):
+    track = factories['music.Track']()
+    user = factories['users.User']()
+    f = TrackFavorite.add(track, user)
+
+    assert f.track == track
+    assert f.user == user
+
+
+def test_user_can_get_his_favorites(factories, logged_in_client, client):
+    favorite = factories['favorites.TrackFavorite'](user=logged_in_client.user)
+    url = reverse('api:v1:favorites:tracks-list')
+    response = logged_in_client.get(url)
+
+    expected = [
+        {
+            'track': favorite.track.pk,
+            'id': favorite.id,
+            'creation_date': favorite.creation_date.isoformat().replace('+00:00', 'Z'),
+        }
+    ]
+    parsed_json = json.loads(response.content.decode('utf-8'))
+
+    assert expected == parsed_json['results']
+
+
+def test_user_can_add_favorite_via_api(factories, logged_in_client, client):
+    track = factories['music.Track']()
+    url = reverse('api:v1:favorites:tracks-list')
+    response = logged_in_client.post(url, {'track': track.pk})
+
+    favorite = TrackFavorite.objects.latest('id')
+    expected = {
+        'track': track.pk,
+        'id': favorite.id,
+        'creation_date': favorite.creation_date.isoformat().replace('+00:00', 'Z'),
+    }
+    parsed_json = json.loads(response.content.decode('utf-8'))
+
+    assert expected == parsed_json
+    assert favorite.track == track
+    assert favorite.user == logged_in_client.user
+
+
+def test_user_can_remove_favorite_via_api(logged_in_client, factories, client):
+    favorite = factories['favorites.TrackFavorite'](user=logged_in_client.user)
+    url = reverse('api:v1:favorites:tracks-detail', kwargs={'pk': favorite.pk})
+    response = client.delete(url, {'track': favorite.track.pk})
+    assert response.status_code == 204
+    assert TrackFavorite.objects.count() == 0
+
+def test_user_can_remove_favorite_via_api_using_track_id(factories, logged_in_client):
+    favorite = factories['favorites.TrackFavorite'](user=logged_in_client.user)
+
+    url = reverse('api:v1:favorites:tracks-remove')
+    response = logged_in_client.delete(
+        url, json.dumps({'track': favorite.track.pk}),
+        content_type='application/json'
+    )
+
+    assert response.status_code == 204
+    assert TrackFavorite.objects.count() == 0
+
+
+@pytest.mark.parametrize('url,method', [
+    ('api:v1:favorites:tracks-list', 'get'),
+])
+def test_url_require_auth(url, method, db, settings, client):
+    settings.API_AUTHENTICATION_REQUIRED = True
+    url = reverse(url)
+    response = getattr(client, method)(url)
+    assert response.status_code == 401
+
+
+def test_can_filter_tracks_by_favorites(factories, logged_in_client):
+    favorite = factories['favorites.TrackFavorite'](user=logged_in_client.user)
+
+    url = reverse('api:v1:tracks-list')
+    response = logged_in_client.get(url, data={'favorites': True})
+
+    parsed_json = json.loads(response.content.decode('utf-8'))
+    assert parsed_json['count'] == 1
+    assert parsed_json['results'][0]['id'] == favorite.track.id

api/tests/test_history.py

+import random
+import json
+from django.urls import reverse
+from django.core.exceptions import ValidationError
+from django.utils import timezone
+
+from funkwhale_api.history import models
+
+
+def test_can_create_listening(factories):
+    track = factories['music.Track']()
+    user = factories['users.User']()
+    now = timezone.now()
+    l = models.Listening.objects.create(user=user, track=track)
+
+
+def test_anonymous_user_can_create_listening_via_api(client, factories, settings):
+    settings.API_AUTHENTICATION_REQUIRED = False
+    track = factories['music.Track']()
+    url = reverse('api:v1:history:listenings-list')
+    response = client.post(url, {
+        'track': track.pk,
+    })
+
+    listening = models.Listening.objects.latest('id')
+
+    assert listening.track == track
+    assert listening.session_key == client.session.session_key
+
+
+def test_logged_in_user_can_create_listening_via_api(logged_in_client, factories):
+    track = factories['music.Track']()
+
+    url = reverse('api:v1:history:listenings-list')
+    response = logged_in_client.post(url, {
+        'track': track.pk,
+    })
+
+    listening = models.Listening.objects.latest('id')
+
+    assert listening.track == track
+    assert listening.user == logged_in_client.user

api/tests/test_jwt_querystring.py

+from django.urls import reverse
+from rest_framework_jwt.settings import api_settings
+
+jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
+jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
+
+
+def test_can_authenticate_using_token_param_in_url(factories, settings, client):
+    user = factories['users.User']()
+    settings.API_AUTHENTICATION_REQUIRED = True
+    url = reverse('api:v1:tracks-list')
+    response = client.get(url)
+
+    assert response.status_code == 401
+
+    payload = jwt_payload_handler(user)
+    token = jwt_encode_handler(payload)
+    response = client.get(url, data={
+        'jwt': token
+    })
+    assert response.status_code == 200

api/tests/test_playlists.py

+import json
+from django.urls import reverse
+from django.core.exceptions import ValidationError
+from django.utils import timezone
+
+from funkwhale_api.playlists import models
+from funkwhale_api.playlists.serializers import PlaylistSerializer
+
+
+
+def test_can_create_playlist(factories):
+    tracks = factories['music.Track'].create_batch(5)
+    playlist = factories['playlists.Playlist']()
+
+    previous = None
+    for track in tracks:
+        previous = playlist.add_track(track, previous=previous)
+
+    playlist_tracks = list(playlist.playlist_tracks.all())
+
+    previous = None
+    for idx, track in enumerate(tracks):
+        plt = playlist_tracks[idx]
+        assert plt.position == idx
+        assert plt.track == track
+        if previous:
+            assert playlist_tracks[idx + 1] == previous
+        assert plt.playlist == playlist
+
+
+def test_can_create_playlist_via_api(logged_in_client):
+    url = reverse('api:v1:playlists-list')
+    data = {
+        'name': 'test',
+    }
+
+    response = logged_in_client.post(url, data)
+
+    playlist = logged_in_client.user.playlists.latest('id')
+    assert playlist.name == 'test'
+
+
+def test_can_add_playlist_track_via_api(factories, logged_in_client):
+    tracks = factories['music.Track'].create_batch(5)
+    playlist = factories['playlists.Playlist'](user=logged_in_client.user)
+    url = reverse('api:v1:playlist-tracks-list')
+    data = {
+        'playlist': playlist.pk,
+        'track': tracks[0].pk
+    }
+
+    response = logged_in_client.post(url, data)
+    plts = logged_in_client.user.playlists.latest('id').playlist_tracks.all()
+    assert plts.first().track == tracks[0]

api/tests/test_radios.py

+import json
+import random
+import pytest
+
+from django.urls import reverse
+from django.core.exceptions import ValidationError
+
+
+from funkwhale_api.radios import radios
+from funkwhale_api.radios import models
+from funkwhale_api.favorites.models import TrackFavorite
+
+
+def test_can_pick_track_from_choices():
+    choices = [1, 2, 3, 4, 5]
+
+    radio = radios.SimpleRadio()
+
+    first_pick = radio.pick(choices=choices)
+
+    assert first_pick in choices
+
+    previous_choices = [first_pick]
+    for remaining_choice in choices:
+        pick = radio.pick(choices=choices, previous_choices=previous_choices)
+        assert pick in set(choices).difference(previous_choices)
+
+
+def test_can_pick_by_weight():
+    choices_with_weight = [
+        # choice, weight
+        (1, 1),
+        (2, 2),
+        (3, 3),
+        (4, 4),
+        (5, 5),
+    ]
+
+    picks = {choice: 0 for choice, weight in choices_with_weight}
+
+    for i in range(1000):
+        radio = radios.SimpleRadio()
+        pick = radio.weighted_pick(choices=choices_with_weight)
+        picks[pick] = picks[pick] + 1
+
+    assert picks[5] > picks[4]
+    assert picks[4] > picks[3]
+    assert picks[3] > picks[2]
+    assert picks[2] > picks[1]
+
+
+def test_can_get_choices_for_favorites_radio(factories):
+    tracks = factories['music.Track'].create_batch(100)
+    user = factories['users.User']()
+    for i in range(20):
+        TrackFavorite.add(track=random.choice(tracks), user=user)
+
+    radio = radios.FavoritesRadio()
+    choices = radio.get_choices(user=user)
+
+    assert choices.count() == user.track_favorites.all().count()
+
+    for favorite in user.track_favorites.all():
+        assert favorite.track in choices
+
+    for i in range(20):
+        pick = radio.pick(user=user)
+        assert pick in choices
+
+
+def test_can_use_radio_session_to_filter_choices(factories):
+    tracks = factories['music.Track'].create_batch(30)
+    user = factories['users.User']()
+    radio = radios.RandomRadio()
+    session = radio.start_session(user)
+
+    for i in range(30):
+        p = radio.pick()
+
+    # ensure 30 differents tracks have been suggested
+    tracks_id = [
+        session_track.track.pk
+        for session_track in session.session_tracks.all()]
+    assert len(set(tracks_id)) == 30
+
+
+def test_can_restore_radio_from_previous_session(factories):
+    user = factories['users.User']()
+    radio = radios.RandomRadio()
+    session = radio.start_session(user)
+
+    restarted_radio = radios.RandomRadio(session)
+    assert radio.session == restarted_radio.session
+
+
+def test_can_start_radio_for_logged_in_user(logged_in_client):
+    url = reverse('api:v1:radios:sessions-list')
+    response = logged_in_client.post(url, {'radio_type': 'random'})
+    session = models.RadioSession.objects.latest('id')
+    assert session.radio_type == 'random'
+    assert session.user == logged_in_client.user
+
+
+def test_can_start_radio_for_anonymous_user(client, db):
+    url = reverse('api:v1:radios:sessions-list')
+    response = client.post(url, {'radio_type': 'random'})
+    session = models.RadioSession.objects.latest('id')
+
+    assert session.radio_type == 'random'
+    assert session.user is None
+    assert session.session_key == client.session.session_key
+
+
+def test_can_get_track_for_session_from_api(factories, logged_in_client):
+    tracks = factories['music.Track'].create_batch(size=1)
+
+    url = reverse('api:v1:radios:sessions-list')
+    response = logged_in_client.post(url, {'radio_type': 'random'})
+    session = models.RadioSession.objects.latest('id')
+
+    url = reverse('api:v1:radios:tracks-list')
+    response = logged_in_client.post(url, {'session': session.pk})
+    data = json.loads(response.content.decode('utf-8'))
+
+    assert data['track']['id'] == tracks[0].id
+    assert data['position'] == 1
+
+    next_track = factories['music.Track']()
+    response = logged_in_client.post(url, {'session': session.pk})
+    data = json.loads(response.content.decode('utf-8'))
+
+    assert data['track']['id'] == next_track.id
+    assert data['position'] == 2
+
+
+def test_related_object_radio_validate_related_object(factories):
+    user = factories['users.User']()
+    # cannot start without related object
+    radio = radios.ArtistRadio()
+    with pytest.raises(ValidationError):
+        radio.start_session(user)
+
+    # cannot start with bad related object type
+    radio = radios.ArtistRadio()
+    with pytest.raises(ValidationError):
+        radio.start_session(user, related_object=user)
+
+
+def test_can_start_artist_radio(factories):
+    user = factories['users.User']()
+    artist = factories['music.Artist']()
+    wrong_tracks = factories['music.Track'].create_batch(5)
+    good_tracks = factories['music.Track'].create_batch(5, artist=artist)
+
+    radio = radios.ArtistRadio()
+    session = radio.start_session(user, related_object=artist)
+    assert session.radio_type == 'artist'
+    for i in range(5):
+        assert radio.pick() in good_tracks
+
+
+def test_can_start_tag_radio(factories):
+    user = factories['users.User']()
+    tag = factories['taggit.Tag']()
+    wrong_tracks = factories['music.Track'].create_batch(5)
+    good_tracks = factories['music.Track'].create_batch(5, tags=[tag])
+
+    radio = radios.TagRadio()
+    session = radio.start_session(user, related_object=tag)
+    assert session.radio_type =='tag'
+    for i in range(5):
+        assert radio.pick() in good_tracks
+
+
+def test_can_start_artist_radio_from_api(client, factories):
+    artist = factories['music.Artist']()
+    url = reverse('api:v1:radios:sessions-list')
+
+    response = client.post(
+        url, {'radio_type': 'artist', 'related_object_id': artist.id})
+    session = models.RadioSession.objects.latest('id')
+    assert session.radio_type, 'artist'
+    assert session.related_object, artist
+
+
+def test_can_start_less_listened_radio(factories):
+    user = factories['users.User']()
+    history = factories['history.Listening'].create_batch(5, user=user)
+    wrong_tracks = [h.track for h in history]
+    good_tracks = factories['music.Track'].create_batch(size=5)
+    radio = radios.LessListenedRadio()
+    session = radio.start_session(user)
+    assert session.related_object == user
+    for i in range(5):
+        assert radio.pick() in good_tracks