funkwhale/api/tests/music/test_models.py

import os
import pytest

from funkwhale_api.music import models
from funkwhale_api.music import importers
from funkwhale_api.music import tasks

DATA_DIR = os.path.dirname(os.path.abspath(__file__))


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(factories):
    album_data = {
        "artist-credit": [
            {
                "artist": {
                    "disambiguation": "George Shaw",
                    "id": "62c3befb-6366-4585-b256-809472333801",
                    "name": "Adhesive Wombat",
                    "sort-name": "Wombat, Adhesive",
                }
            }
        ],
        "artist-credit-phrase": "Adhesive Wombat",
        "country": "XW",
        "date": "2013-06-05",
        "id": "a50d2a81-2a50-484d-9cb4-b9f6833f583e",
        "status": "Official",
        "title": "Marsupial Madness",
        "release-group": {"id": "447b4979-2178-405c-bfe6-46bf0b09e6c7"},
    }
    artist = factories["music.Artist"](
        mbid=album_data["artist-credit"][0]["artist"]["id"]
    )
    cleaned_data = models.Album.clean_musicbrainz_data(album_data)
    album = importers.load(models.Album, cleaned_data, album_data, import_hooks=[])

    assert album.release_group_id == album_data["release-group"]["id"]
    assert album.artist == artist


def test_import_track_from_release(factories, mocker):
    album = factories["music.Album"](mbid="430347cb-0879-3113-9fde-c75b658c298e")
    album_data = {
        "release": {
            "id": album.mbid,
            "title": "Daydream Nation",
            "status": "Official",
            "medium-count": 1,
            "medium-list": [
                {
                    "position": "1",
                    "format": "CD",
                    "track-list": [
                        {
                            "id": "03baca8b-855a-3c05-8f3d-d3235287d84d",
                            "position": "4",
                            "number": "4",
                            "length": "417973",
                            "recording": {
                                "id": "2109e376-132b-40ad-b993-2bb6812e19d4",
                                "title": "Teen Age Riot",
                                "length": "417973",
                            },
                            "track_or_recording_length": "417973",
                        }
                    ],
                    "track-count": 1,
                }
            ],
        }
    }
    mocked_get = mocker.patch(
        "funkwhale_api.musicbrainz.api.releases.get", return_value=album_data
    )
    track_data = album_data["release"]["medium-list"][0]["track-list"][0]
    track = models.Track.get_or_create_from_release(
        "430347cb-0879-3113-9fde-c75b658c298e", track_data["recording"]["id"]
    )[0]
    mocked_get.assert_called_once_with(album.mbid, includes=models.Album.api_includes)
    assert track.title == track_data["recording"]["title"]
    assert track.mbid == track_data["recording"]["id"]
    assert track.album == album
    assert track.artist == album.artist
    assert track.position == int(track_data["position"])


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")
    tasks.import_job_run(import_job_id=job.pk)
    job.refresh_from_db()
    assert job.track_file.track == track


@pytest.mark.parametrize("status", ["pending", "errored", "finished"])
def test_saving_job_updates_batch_status(status, factories, mocker):
    batch = factories["music.ImportBatch"]()

    assert batch.status == "pending"

    job = factories["music.ImportJob"](batch=batch, status=status)

    batch.refresh_from_db()

    assert batch.status == status


@pytest.mark.parametrize(
    "extention,mimetype", [("ogg", "audio/ogg"), ("mp3", "audio/mpeg")]
)
def test_audio_track_mime_type(extention, mimetype, factories):

    name = ".".join(["test", extention])
    path = os.path.join(DATA_DIR, name)
    tf = factories["music.TrackFile"](audio_file__from_path=path)

    assert tf.mimetype == mimetype


def test_track_file_file_name(factories):
    name = "test.mp3"
    path = os.path.join(DATA_DIR, name)
    tf = factories["music.TrackFile"](audio_file__from_path=path)

    assert tf.filename == tf.track.full_name + ".mp3"


def test_track_get_file_size(factories):
    name = "test.mp3"
    path = os.path.join(DATA_DIR, name)
    tf = factories["music.TrackFile"](audio_file__from_path=path)

    assert tf.get_file_size() == 297745


def test_track_get_file_size_federation(factories):
    tf = factories["music.TrackFile"](
        federation=True, library_track__with_audio_file=True
    )

    assert tf.get_file_size() == tf.library_track.audio_file.size


def test_track_get_file_size_in_place(factories):
    name = "test.mp3"
    path = os.path.join(DATA_DIR, name)
    tf = factories["music.TrackFile"](in_place=True, source="file://{}".format(path))

    assert tf.get_file_size() == 297745


def test_album_get_image_content(factories):
    album = factories["music.Album"]()
    album.get_image(data={"content": b"test", "mimetype": "image/jpeg"})
    album.refresh_from_db()

    assert album.cover.read() == b"test"