mirror of
https://github.com/beetbox/beets.git
synced 2025-12-06 00:24:25 +01:00
1080 lines
38 KiB
Python
1080 lines
38 KiB
Python
# This file is part of beets.
|
|
# Copyright 2016, Adrian Sampson.
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining
|
|
# a copy of this software and associated documentation files (the
|
|
# "Software"), to deal in the Software without restriction, including
|
|
# without limitation the rights to use, copy, modify, merge, publish,
|
|
# distribute, sublicense, and/or sell copies of the Software, and to
|
|
# permit persons to whom the Software is furnished to do so, subject to
|
|
# the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be
|
|
# included in all copies or substantial portions of the Software.
|
|
|
|
"""Tests for MusicBrainz API wrapper."""
|
|
|
|
import unittest
|
|
from unittest import mock
|
|
|
|
import pytest
|
|
|
|
from beets import config
|
|
from beets.library import Item
|
|
from beets.test.helper import BeetsTestCase, PluginMixin
|
|
from beetsplug import musicbrainz
|
|
|
|
|
|
class MusicBrainzTestCase(BeetsTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.mb = musicbrainz.MusicBrainzPlugin()
|
|
|
|
|
|
class MBAlbumInfoTest(MusicBrainzTestCase):
|
|
def _make_release(
|
|
self,
|
|
date_str="2009",
|
|
tracks=None,
|
|
track_length=None,
|
|
track_artist=False,
|
|
multi_artist_credit=False,
|
|
data_tracks=None,
|
|
medium_format="FORMAT",
|
|
):
|
|
release = {
|
|
"title": "ALBUM TITLE",
|
|
"id": "ALBUM ID",
|
|
"asin": "ALBUM ASIN",
|
|
"disambiguation": "R_DISAMBIGUATION",
|
|
"release-group": {
|
|
"type": "Album",
|
|
"first-release-date": date_str,
|
|
"id": "RELEASE GROUP ID",
|
|
"disambiguation": "RG_DISAMBIGUATION",
|
|
},
|
|
"artist-credit": [
|
|
{
|
|
"artist": {
|
|
"name": "ARTIST NAME",
|
|
"id": "ARTIST ID",
|
|
"sort-name": "ARTIST SORT NAME",
|
|
},
|
|
"name": "ARTIST CREDIT",
|
|
}
|
|
],
|
|
"date": "3001",
|
|
"medium-list": [],
|
|
"label-info-list": [
|
|
{
|
|
"catalog-number": "CATALOG NUMBER",
|
|
"label": {"name": "LABEL NAME"},
|
|
}
|
|
],
|
|
"text-representation": {
|
|
"script": "SCRIPT",
|
|
"language": "LANGUAGE",
|
|
},
|
|
"country": "COUNTRY",
|
|
"status": "STATUS",
|
|
"barcode": "BARCODE",
|
|
}
|
|
|
|
if multi_artist_credit:
|
|
release["artist-credit"].append(" & ") # add join phase
|
|
release["artist-credit"].append(
|
|
{
|
|
"artist": {
|
|
"name": "ARTIST 2 NAME",
|
|
"id": "ARTIST 2 ID",
|
|
"sort-name": "ARTIST 2 SORT NAME",
|
|
},
|
|
"name": "ARTIST MULTI CREDIT",
|
|
}
|
|
)
|
|
|
|
i = 0
|
|
track_list = []
|
|
if tracks:
|
|
for recording in tracks:
|
|
i += 1
|
|
track = {
|
|
"id": f"RELEASE TRACK ID {i}",
|
|
"recording": recording,
|
|
"position": i,
|
|
"number": "A1",
|
|
}
|
|
if track_length:
|
|
# Track lengths are distinct from recording lengths.
|
|
track["length"] = track_length
|
|
if track_artist:
|
|
# Similarly, track artists can differ from recording
|
|
# artists.
|
|
track["artist-credit"] = [
|
|
{
|
|
"artist": {
|
|
"name": "TRACK ARTIST NAME",
|
|
"id": "TRACK ARTIST ID",
|
|
"sort-name": "TRACK ARTIST SORT NAME",
|
|
},
|
|
"name": "TRACK ARTIST CREDIT",
|
|
}
|
|
]
|
|
|
|
if multi_artist_credit:
|
|
track["artist-credit"].append(" & ") # add join phase
|
|
track["artist-credit"].append(
|
|
{
|
|
"artist": {
|
|
"name": "TRACK ARTIST 2 NAME",
|
|
"id": "TRACK ARTIST 2 ID",
|
|
"sort-name": "TRACK ARTIST 2 SORT NAME",
|
|
},
|
|
"name": "TRACK ARTIST 2 CREDIT",
|
|
}
|
|
)
|
|
|
|
track_list.append(track)
|
|
data_track_list = []
|
|
if data_tracks:
|
|
for recording in data_tracks:
|
|
i += 1
|
|
data_track = {
|
|
"id": f"RELEASE TRACK ID {i}",
|
|
"recording": recording,
|
|
"position": i,
|
|
"number": "A1",
|
|
}
|
|
data_track_list.append(data_track)
|
|
release["medium-list"].append(
|
|
{
|
|
"position": "1",
|
|
"track-list": track_list,
|
|
"data-track-list": data_track_list,
|
|
"format": medium_format,
|
|
"title": "MEDIUM TITLE",
|
|
}
|
|
)
|
|
return release
|
|
|
|
def _make_track(
|
|
self,
|
|
title,
|
|
tr_id,
|
|
duration,
|
|
artist=False,
|
|
video=False,
|
|
disambiguation=None,
|
|
remixer=False,
|
|
multi_artist_credit=False,
|
|
):
|
|
track = {
|
|
"title": title,
|
|
"id": tr_id,
|
|
}
|
|
if duration is not None:
|
|
track["length"] = duration
|
|
if artist:
|
|
track["artist-credit"] = [
|
|
{
|
|
"artist": {
|
|
"name": "RECORDING ARTIST NAME",
|
|
"id": "RECORDING ARTIST ID",
|
|
"sort-name": "RECORDING ARTIST SORT NAME",
|
|
},
|
|
"name": "RECORDING ARTIST CREDIT",
|
|
}
|
|
]
|
|
if multi_artist_credit:
|
|
track["artist-credit"].append(" & ") # add join phase
|
|
track["artist-credit"].append(
|
|
{
|
|
"artist": {
|
|
"name": "RECORDING ARTIST 2 NAME",
|
|
"id": "RECORDING ARTIST 2 ID",
|
|
"sort-name": "RECORDING ARTIST 2 SORT NAME",
|
|
},
|
|
"name": "RECORDING ARTIST 2 CREDIT",
|
|
}
|
|
)
|
|
if remixer:
|
|
track["artist-relation-list"] = [
|
|
{
|
|
"type": "remixer",
|
|
"type-id": "RELATION TYPE ID",
|
|
"target": "RECORDING REMIXER ARTIST ID",
|
|
"direction": "RECORDING RELATION DIRECTION",
|
|
"artist": {
|
|
"id": "RECORDING REMIXER ARTIST ID",
|
|
"type": "RECORDING REMIXER ARTIST TYPE",
|
|
"name": "RECORDING REMIXER ARTIST NAME",
|
|
"sort-name": "RECORDING REMIXER ARTIST SORT NAME",
|
|
},
|
|
}
|
|
]
|
|
if video:
|
|
track["video"] = "true"
|
|
if disambiguation:
|
|
track["disambiguation"] = disambiguation
|
|
return track
|
|
|
|
def test_parse_release_with_year(self):
|
|
release = self._make_release("1984")
|
|
d = self.mb.album_info(release)
|
|
assert d.album == "ALBUM TITLE"
|
|
assert d.album_id == "ALBUM ID"
|
|
assert d.artist == "ARTIST NAME"
|
|
assert d.artist_id == "ARTIST ID"
|
|
assert d.original_year == 1984
|
|
assert d.year == 3001
|
|
assert d.artist_credit == "ARTIST CREDIT"
|
|
|
|
def test_parse_release_type(self):
|
|
release = self._make_release("1984")
|
|
d = self.mb.album_info(release)
|
|
assert d.albumtype == "album"
|
|
|
|
def test_parse_release_full_date(self):
|
|
release = self._make_release("1987-03-31")
|
|
d = self.mb.album_info(release)
|
|
assert d.original_year == 1987
|
|
assert d.original_month == 3
|
|
assert d.original_day == 31
|
|
|
|
def test_parse_tracks(self):
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
release = self._make_release(tracks=tracks)
|
|
|
|
d = self.mb.album_info(release)
|
|
t = d.tracks
|
|
assert len(t) == 2
|
|
assert t[0].title == "TITLE ONE"
|
|
assert t[0].track_id == "ID ONE"
|
|
assert t[0].length == 100.0
|
|
assert t[1].title == "TITLE TWO"
|
|
assert t[1].track_id == "ID TWO"
|
|
assert t[1].length == 200.0
|
|
|
|
def test_parse_track_indices(self):
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
release = self._make_release(tracks=tracks)
|
|
|
|
d = self.mb.album_info(release)
|
|
t = d.tracks
|
|
assert t[0].medium_index == 1
|
|
assert t[0].index == 1
|
|
assert t[1].medium_index == 2
|
|
assert t[1].index == 2
|
|
|
|
def test_parse_medium_numbers_single_medium(self):
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
release = self._make_release(tracks=tracks)
|
|
|
|
d = self.mb.album_info(release)
|
|
assert d.mediums == 1
|
|
t = d.tracks
|
|
assert t[0].medium == 1
|
|
assert t[1].medium == 1
|
|
|
|
def test_parse_medium_numbers_two_mediums(self):
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
release = self._make_release(tracks=[tracks[0]])
|
|
second_track_list = [
|
|
{
|
|
"id": "RELEASE TRACK ID 2",
|
|
"recording": tracks[1],
|
|
"position": "1",
|
|
"number": "A1",
|
|
}
|
|
]
|
|
release["medium-list"].append(
|
|
{
|
|
"position": "2",
|
|
"track-list": second_track_list,
|
|
}
|
|
)
|
|
|
|
d = self.mb.album_info(release)
|
|
assert d.mediums == 2
|
|
t = d.tracks
|
|
assert t[0].medium == 1
|
|
assert t[0].medium_index == 1
|
|
assert t[0].index == 1
|
|
assert t[1].medium == 2
|
|
assert t[1].medium_index == 1
|
|
assert t[1].index == 2
|
|
|
|
def test_parse_release_year_month_only(self):
|
|
release = self._make_release("1987-03")
|
|
d = self.mb.album_info(release)
|
|
assert d.original_year == 1987
|
|
assert d.original_month == 3
|
|
|
|
def test_no_durations(self):
|
|
tracks = [self._make_track("TITLE", "ID", None)]
|
|
release = self._make_release(tracks=tracks)
|
|
d = self.mb.album_info(release)
|
|
assert d.tracks[0].length is None
|
|
|
|
def test_track_length_overrides_recording_length(self):
|
|
tracks = [self._make_track("TITLE", "ID", 1.0 * 1000.0)]
|
|
release = self._make_release(tracks=tracks, track_length=2.0 * 1000.0)
|
|
d = self.mb.album_info(release)
|
|
assert d.tracks[0].length == 2.0
|
|
|
|
def test_no_release_date(self):
|
|
release = self._make_release(None)
|
|
d = self.mb.album_info(release)
|
|
assert not d.original_year
|
|
assert not d.original_month
|
|
assert not d.original_day
|
|
|
|
def test_various_artists_defaults_false(self):
|
|
release = self._make_release(None)
|
|
d = self.mb.album_info(release)
|
|
assert not d.va
|
|
|
|
def test_detect_various_artists(self):
|
|
release = self._make_release(None)
|
|
release["artist-credit"][0]["artist"]["id"] = (
|
|
musicbrainz.VARIOUS_ARTISTS_ID
|
|
)
|
|
d = self.mb.album_info(release)
|
|
assert d.va
|
|
|
|
def test_parse_artist_sort_name(self):
|
|
release = self._make_release(None)
|
|
d = self.mb.album_info(release)
|
|
assert d.artist_sort == "ARTIST SORT NAME"
|
|
|
|
def test_parse_releasegroupid(self):
|
|
release = self._make_release(None)
|
|
d = self.mb.album_info(release)
|
|
assert d.releasegroup_id == "RELEASE GROUP ID"
|
|
|
|
def test_parse_asin(self):
|
|
release = self._make_release(None)
|
|
d = self.mb.album_info(release)
|
|
assert d.asin == "ALBUM ASIN"
|
|
|
|
def test_parse_catalognum(self):
|
|
release = self._make_release(None)
|
|
d = self.mb.album_info(release)
|
|
assert d.catalognum == "CATALOG NUMBER"
|
|
|
|
def test_parse_textrepr(self):
|
|
release = self._make_release(None)
|
|
d = self.mb.album_info(release)
|
|
assert d.script == "SCRIPT"
|
|
assert d.language == "LANGUAGE"
|
|
|
|
def test_parse_country(self):
|
|
release = self._make_release(None)
|
|
d = self.mb.album_info(release)
|
|
assert d.country == "COUNTRY"
|
|
|
|
def test_parse_status(self):
|
|
release = self._make_release(None)
|
|
d = self.mb.album_info(release)
|
|
assert d.albumstatus == "STATUS"
|
|
|
|
def test_parse_barcode(self):
|
|
release = self._make_release(None)
|
|
d = self.mb.album_info(release)
|
|
assert d.barcode == "BARCODE"
|
|
|
|
def test_parse_media(self):
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
release = self._make_release(None, tracks=tracks)
|
|
d = self.mb.album_info(release)
|
|
assert d.media == "FORMAT"
|
|
|
|
def test_parse_disambig(self):
|
|
release = self._make_release(None)
|
|
d = self.mb.album_info(release)
|
|
assert d.albumdisambig == "R_DISAMBIGUATION"
|
|
assert d.releasegroupdisambig == "RG_DISAMBIGUATION"
|
|
|
|
def test_parse_disctitle(self):
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
release = self._make_release(None, tracks=tracks)
|
|
d = self.mb.album_info(release)
|
|
t = d.tracks
|
|
assert t[0].disctitle == "MEDIUM TITLE"
|
|
assert t[1].disctitle == "MEDIUM TITLE"
|
|
|
|
def test_missing_language(self):
|
|
release = self._make_release(None)
|
|
del release["text-representation"]["language"]
|
|
d = self.mb.album_info(release)
|
|
assert d.language is None
|
|
|
|
def test_parse_recording_artist(self):
|
|
tracks = [self._make_track("a", "b", 1, True)]
|
|
release = self._make_release(None, tracks=tracks)
|
|
track = self.mb.album_info(release).tracks[0]
|
|
assert track.artist == "RECORDING ARTIST NAME"
|
|
assert track.artist_id == "RECORDING ARTIST ID"
|
|
assert track.artist_sort == "RECORDING ARTIST SORT NAME"
|
|
assert track.artist_credit == "RECORDING ARTIST CREDIT"
|
|
|
|
def test_parse_recording_artist_multi(self):
|
|
tracks = [self._make_track("a", "b", 1, True, multi_artist_credit=True)]
|
|
release = self._make_release(None, tracks=tracks)
|
|
track = self.mb.album_info(release).tracks[0]
|
|
assert track.artist == "RECORDING ARTIST NAME & RECORDING ARTIST 2 NAME"
|
|
assert track.artist_id == "RECORDING ARTIST ID"
|
|
assert (
|
|
track.artist_sort
|
|
== "RECORDING ARTIST SORT NAME & RECORDING ARTIST 2 SORT NAME"
|
|
)
|
|
assert (
|
|
track.artist_credit
|
|
== "RECORDING ARTIST CREDIT & RECORDING ARTIST 2 CREDIT"
|
|
)
|
|
|
|
assert track.artists == [
|
|
"RECORDING ARTIST NAME",
|
|
"RECORDING ARTIST 2 NAME",
|
|
]
|
|
assert track.artists_ids == [
|
|
"RECORDING ARTIST ID",
|
|
"RECORDING ARTIST 2 ID",
|
|
]
|
|
assert track.artists_sort == [
|
|
"RECORDING ARTIST SORT NAME",
|
|
"RECORDING ARTIST 2 SORT NAME",
|
|
]
|
|
assert track.artists_credit == [
|
|
"RECORDING ARTIST CREDIT",
|
|
"RECORDING ARTIST 2 CREDIT",
|
|
]
|
|
|
|
def test_track_artist_overrides_recording_artist(self):
|
|
tracks = [self._make_track("a", "b", 1, True)]
|
|
release = self._make_release(None, tracks=tracks, track_artist=True)
|
|
track = self.mb.album_info(release).tracks[0]
|
|
assert track.artist == "TRACK ARTIST NAME"
|
|
assert track.artist_id == "TRACK ARTIST ID"
|
|
assert track.artist_sort == "TRACK ARTIST SORT NAME"
|
|
assert track.artist_credit == "TRACK ARTIST CREDIT"
|
|
|
|
def test_track_artist_overrides_recording_artist_multi(self):
|
|
tracks = [self._make_track("a", "b", 1, True, multi_artist_credit=True)]
|
|
release = self._make_release(
|
|
None, tracks=tracks, track_artist=True, multi_artist_credit=True
|
|
)
|
|
track = self.mb.album_info(release).tracks[0]
|
|
assert track.artist == "TRACK ARTIST NAME & TRACK ARTIST 2 NAME"
|
|
assert track.artist_id == "TRACK ARTIST ID"
|
|
assert (
|
|
track.artist_sort
|
|
== "TRACK ARTIST SORT NAME & TRACK ARTIST 2 SORT NAME"
|
|
)
|
|
assert (
|
|
track.artist_credit == "TRACK ARTIST CREDIT & TRACK ARTIST 2 CREDIT"
|
|
)
|
|
|
|
assert track.artists == ["TRACK ARTIST NAME", "TRACK ARTIST 2 NAME"]
|
|
assert track.artists_ids == ["TRACK ARTIST ID", "TRACK ARTIST 2 ID"]
|
|
assert track.artists_sort == [
|
|
"TRACK ARTIST SORT NAME",
|
|
"TRACK ARTIST 2 SORT NAME",
|
|
]
|
|
assert track.artists_credit == [
|
|
"TRACK ARTIST CREDIT",
|
|
"TRACK ARTIST 2 CREDIT",
|
|
]
|
|
|
|
def test_parse_recording_remixer(self):
|
|
tracks = [self._make_track("a", "b", 1, remixer=True)]
|
|
release = self._make_release(None, tracks=tracks)
|
|
track = self.mb.album_info(release).tracks[0]
|
|
assert track.remixer == "RECORDING REMIXER ARTIST NAME"
|
|
|
|
def test_data_source(self):
|
|
release = self._make_release()
|
|
d = self.mb.album_info(release)
|
|
assert d.data_source == "MusicBrainz"
|
|
|
|
def test_ignored_media(self):
|
|
config["match"]["ignored_media"] = ["IGNORED1", "IGNORED2"]
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
release = self._make_release(tracks=tracks, medium_format="IGNORED1")
|
|
d = self.mb.album_info(release)
|
|
assert len(d.tracks) == 0
|
|
|
|
def test_no_ignored_media(self):
|
|
config["match"]["ignored_media"] = ["IGNORED1", "IGNORED2"]
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
release = self._make_release(tracks=tracks, medium_format="NON-IGNORED")
|
|
d = self.mb.album_info(release)
|
|
assert len(d.tracks) == 2
|
|
|
|
def test_skip_data_track(self):
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track("[data track]", "ID DATA TRACK", 100.0 * 1000.0),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
release = self._make_release(tracks=tracks)
|
|
d = self.mb.album_info(release)
|
|
assert len(d.tracks) == 2
|
|
assert d.tracks[0].title == "TITLE ONE"
|
|
assert d.tracks[1].title == "TITLE TWO"
|
|
|
|
def test_skip_audio_data_tracks_by_default(self):
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
data_tracks = [
|
|
self._make_track(
|
|
"TITLE AUDIO DATA", "ID DATA TRACK", 100.0 * 1000.0
|
|
)
|
|
]
|
|
release = self._make_release(tracks=tracks, data_tracks=data_tracks)
|
|
d = self.mb.album_info(release)
|
|
assert len(d.tracks) == 2
|
|
assert d.tracks[0].title == "TITLE ONE"
|
|
assert d.tracks[1].title == "TITLE TWO"
|
|
|
|
def test_no_skip_audio_data_tracks_if_configured(self):
|
|
config["match"]["ignore_data_tracks"] = False
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
data_tracks = [
|
|
self._make_track(
|
|
"TITLE AUDIO DATA", "ID DATA TRACK", 100.0 * 1000.0
|
|
)
|
|
]
|
|
release = self._make_release(tracks=tracks, data_tracks=data_tracks)
|
|
d = self.mb.album_info(release)
|
|
assert len(d.tracks) == 3
|
|
assert d.tracks[0].title == "TITLE ONE"
|
|
assert d.tracks[1].title == "TITLE TWO"
|
|
assert d.tracks[2].title == "TITLE AUDIO DATA"
|
|
|
|
def test_skip_video_tracks_by_default(self):
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track(
|
|
"TITLE VIDEO", "ID VIDEO", 100.0 * 1000.0, False, True
|
|
),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
release = self._make_release(tracks=tracks)
|
|
d = self.mb.album_info(release)
|
|
assert len(d.tracks) == 2
|
|
assert d.tracks[0].title == "TITLE ONE"
|
|
assert d.tracks[1].title == "TITLE TWO"
|
|
|
|
def test_skip_video_data_tracks_by_default(self):
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
data_tracks = [
|
|
self._make_track(
|
|
"TITLE VIDEO", "ID VIDEO", 100.0 * 1000.0, False, True
|
|
)
|
|
]
|
|
release = self._make_release(tracks=tracks, data_tracks=data_tracks)
|
|
d = self.mb.album_info(release)
|
|
assert len(d.tracks) == 2
|
|
assert d.tracks[0].title == "TITLE ONE"
|
|
assert d.tracks[1].title == "TITLE TWO"
|
|
|
|
def test_no_skip_video_tracks_if_configured(self):
|
|
config["match"]["ignore_data_tracks"] = False
|
|
config["match"]["ignore_video_tracks"] = False
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track(
|
|
"TITLE VIDEO", "ID VIDEO", 100.0 * 1000.0, False, True
|
|
),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
release = self._make_release(tracks=tracks)
|
|
d = self.mb.album_info(release)
|
|
assert len(d.tracks) == 3
|
|
assert d.tracks[0].title == "TITLE ONE"
|
|
assert d.tracks[1].title == "TITLE VIDEO"
|
|
assert d.tracks[2].title == "TITLE TWO"
|
|
|
|
def test_no_skip_video_data_tracks_if_configured(self):
|
|
config["match"]["ignore_data_tracks"] = False
|
|
config["match"]["ignore_video_tracks"] = False
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track("TITLE TWO", "ID TWO", 200.0 * 1000.0),
|
|
]
|
|
data_tracks = [
|
|
self._make_track(
|
|
"TITLE VIDEO", "ID VIDEO", 100.0 * 1000.0, False, True
|
|
)
|
|
]
|
|
release = self._make_release(tracks=tracks, data_tracks=data_tracks)
|
|
d = self.mb.album_info(release)
|
|
assert len(d.tracks) == 3
|
|
assert d.tracks[0].title == "TITLE ONE"
|
|
assert d.tracks[1].title == "TITLE TWO"
|
|
assert d.tracks[2].title == "TITLE VIDEO"
|
|
|
|
def test_track_disambiguation(self):
|
|
tracks = [
|
|
self._make_track("TITLE ONE", "ID ONE", 100.0 * 1000.0),
|
|
self._make_track(
|
|
"TITLE TWO",
|
|
"ID TWO",
|
|
200.0 * 1000.0,
|
|
disambiguation="SECOND TRACK",
|
|
),
|
|
]
|
|
release = self._make_release(tracks=tracks)
|
|
|
|
d = self.mb.album_info(release)
|
|
t = d.tracks
|
|
assert len(t) == 2
|
|
assert t[0].trackdisambig is None
|
|
assert t[1].trackdisambig == "SECOND TRACK"
|
|
|
|
|
|
class ArtistFlatteningTest(unittest.TestCase):
|
|
def _credit_dict(self, suffix=""):
|
|
return {
|
|
"artist": {
|
|
"name": "NAME" + suffix,
|
|
"sort-name": "SORT" + suffix,
|
|
},
|
|
"name": "CREDIT" + suffix,
|
|
}
|
|
|
|
def _add_alias(self, credit_dict, suffix="", locale="", primary=False):
|
|
alias = {
|
|
"alias": "ALIAS" + suffix,
|
|
"locale": locale,
|
|
"sort-name": "ALIASSORT" + suffix,
|
|
}
|
|
if primary:
|
|
alias["primary"] = "primary"
|
|
if "alias-list" not in credit_dict["artist"]:
|
|
credit_dict["artist"]["alias-list"] = []
|
|
credit_dict["artist"]["alias-list"].append(alias)
|
|
|
|
def test_single_artist(self):
|
|
credit = [self._credit_dict()]
|
|
a, s, c = musicbrainz._flatten_artist_credit(credit)
|
|
assert a == "NAME"
|
|
assert s == "SORT"
|
|
assert c == "CREDIT"
|
|
|
|
a, s, c = musicbrainz._multi_artist_credit(
|
|
credit, include_join_phrase=False
|
|
)
|
|
assert a == ["NAME"]
|
|
assert s == ["SORT"]
|
|
assert c == ["CREDIT"]
|
|
|
|
def test_two_artists(self):
|
|
credit = [self._credit_dict("a"), " AND ", self._credit_dict("b")]
|
|
a, s, c = musicbrainz._flatten_artist_credit(credit)
|
|
assert a == "NAMEa AND NAMEb"
|
|
assert s == "SORTa AND SORTb"
|
|
assert c == "CREDITa AND CREDITb"
|
|
|
|
a, s, c = musicbrainz._multi_artist_credit(
|
|
credit, include_join_phrase=False
|
|
)
|
|
assert a == ["NAMEa", "NAMEb"]
|
|
assert s == ["SORTa", "SORTb"]
|
|
assert c == ["CREDITa", "CREDITb"]
|
|
|
|
def test_alias(self):
|
|
credit_dict = self._credit_dict()
|
|
self._add_alias(credit_dict, suffix="en", locale="en", primary=True)
|
|
self._add_alias(
|
|
credit_dict, suffix="en_GB", locale="en_GB", primary=True
|
|
)
|
|
self._add_alias(credit_dict, suffix="fr", locale="fr")
|
|
self._add_alias(credit_dict, suffix="fr_P", locale="fr", primary=True)
|
|
self._add_alias(credit_dict, suffix="pt_BR", locale="pt_BR")
|
|
|
|
# test no alias
|
|
config["import"]["languages"] = [""]
|
|
flat = musicbrainz._flatten_artist_credit([credit_dict])
|
|
assert flat == ("NAME", "SORT", "CREDIT")
|
|
|
|
# test en primary
|
|
config["import"]["languages"] = ["en"]
|
|
flat = musicbrainz._flatten_artist_credit([credit_dict])
|
|
assert flat == ("ALIASen", "ALIASSORTen", "CREDIT")
|
|
|
|
# test en_GB en primary
|
|
config["import"]["languages"] = ["en_GB", "en"]
|
|
flat = musicbrainz._flatten_artist_credit([credit_dict])
|
|
assert flat == ("ALIASen_GB", "ALIASSORTen_GB", "CREDIT")
|
|
|
|
# test en en_GB primary
|
|
config["import"]["languages"] = ["en", "en_GB"]
|
|
flat = musicbrainz._flatten_artist_credit([credit_dict])
|
|
assert flat == ("ALIASen", "ALIASSORTen", "CREDIT")
|
|
|
|
# test fr primary
|
|
config["import"]["languages"] = ["fr"]
|
|
flat = musicbrainz._flatten_artist_credit([credit_dict])
|
|
assert flat == ("ALIASfr_P", "ALIASSORTfr_P", "CREDIT")
|
|
|
|
# test for not matching non-primary
|
|
config["import"]["languages"] = ["pt_BR", "fr"]
|
|
flat = musicbrainz._flatten_artist_credit([credit_dict])
|
|
assert flat == ("ALIASfr_P", "ALIASSORTfr_P", "CREDIT")
|
|
|
|
|
|
class MBLibraryTest(MusicBrainzTestCase):
|
|
def test_follow_pseudo_releases(self):
|
|
side_effect = [
|
|
{
|
|
"release": {
|
|
"title": "pseudo",
|
|
"id": "d2a6f856-b553-40a0-ac54-a321e8e2da02",
|
|
"status": "Pseudo-Release",
|
|
"medium-list": [
|
|
{
|
|
"track-list": [
|
|
{
|
|
"id": "baz",
|
|
"recording": {
|
|
"title": "translated title",
|
|
"id": "bar",
|
|
"length": 42,
|
|
},
|
|
"position": 9,
|
|
"number": "A1",
|
|
}
|
|
],
|
|
"position": 5,
|
|
}
|
|
],
|
|
"artist-credit": [
|
|
{
|
|
"artist": {
|
|
"name": "some-artist",
|
|
"id": "some-id",
|
|
},
|
|
}
|
|
],
|
|
"release-group": {
|
|
"id": "another-id",
|
|
},
|
|
"release-relation-list": [
|
|
{
|
|
"type": "transl-tracklisting",
|
|
"target": "d2a6f856-b553-40a0-ac54-a321e8e2da01",
|
|
"direction": "backward",
|
|
}
|
|
],
|
|
}
|
|
},
|
|
{
|
|
"release": {
|
|
"title": "actual",
|
|
"id": "d2a6f856-b553-40a0-ac54-a321e8e2da01",
|
|
"status": "Official",
|
|
"medium-list": [
|
|
{
|
|
"track-list": [
|
|
{
|
|
"id": "baz",
|
|
"recording": {
|
|
"title": "original title",
|
|
"id": "bar",
|
|
"length": 42,
|
|
},
|
|
"position": 9,
|
|
"number": "A1",
|
|
}
|
|
],
|
|
"position": 5,
|
|
}
|
|
],
|
|
"artist-credit": [
|
|
{
|
|
"artist": {
|
|
"name": "some-artist",
|
|
"id": "some-id",
|
|
},
|
|
}
|
|
],
|
|
"release-group": {
|
|
"id": "another-id",
|
|
},
|
|
"country": "COUNTRY",
|
|
}
|
|
},
|
|
]
|
|
|
|
with mock.patch("musicbrainzngs.get_release_by_id") as gp:
|
|
gp.side_effect = side_effect
|
|
album = self.mb.album_for_id("d2a6f856-b553-40a0-ac54-a321e8e2da02")
|
|
assert album.country == "COUNTRY"
|
|
|
|
def test_pseudo_releases_with_empty_links(self):
|
|
side_effect = [
|
|
{
|
|
"release": {
|
|
"title": "pseudo",
|
|
"id": "d2a6f856-b553-40a0-ac54-a321e8e2da02",
|
|
"status": "Pseudo-Release",
|
|
"medium-list": [
|
|
{
|
|
"track-list": [
|
|
{
|
|
"id": "baz",
|
|
"recording": {
|
|
"title": "translated title",
|
|
"id": "bar",
|
|
"length": 42,
|
|
},
|
|
"position": 9,
|
|
"number": "A1",
|
|
}
|
|
],
|
|
"position": 5,
|
|
}
|
|
],
|
|
"artist-credit": [
|
|
{
|
|
"artist": {
|
|
"name": "some-artist",
|
|
"id": "some-id",
|
|
},
|
|
}
|
|
],
|
|
"release-group": {
|
|
"id": "another-id",
|
|
},
|
|
"release-relation-list": [],
|
|
}
|
|
},
|
|
]
|
|
|
|
with mock.patch("musicbrainzngs.get_release_by_id") as gp:
|
|
gp.side_effect = side_effect
|
|
album = self.mb.album_for_id("d2a6f856-b553-40a0-ac54-a321e8e2da02")
|
|
assert album.country is None
|
|
|
|
def test_pseudo_releases_without_links(self):
|
|
side_effect = [
|
|
{
|
|
"release": {
|
|
"title": "pseudo",
|
|
"id": "d2a6f856-b553-40a0-ac54-a321e8e2da02",
|
|
"status": "Pseudo-Release",
|
|
"medium-list": [
|
|
{
|
|
"track-list": [
|
|
{
|
|
"id": "baz",
|
|
"recording": {
|
|
"title": "translated title",
|
|
"id": "bar",
|
|
"length": 42,
|
|
},
|
|
"position": 9,
|
|
"number": "A1",
|
|
}
|
|
],
|
|
"position": 5,
|
|
}
|
|
],
|
|
"artist-credit": [
|
|
{
|
|
"artist": {
|
|
"name": "some-artist",
|
|
"id": "some-id",
|
|
},
|
|
}
|
|
],
|
|
"release-group": {
|
|
"id": "another-id",
|
|
},
|
|
}
|
|
},
|
|
]
|
|
|
|
with mock.patch("musicbrainzngs.get_release_by_id") as gp:
|
|
gp.side_effect = side_effect
|
|
album = self.mb.album_for_id("d2a6f856-b553-40a0-ac54-a321e8e2da02")
|
|
assert album.country is None
|
|
|
|
def test_pseudo_releases_with_unsupported_links(self):
|
|
side_effect = [
|
|
{
|
|
"release": {
|
|
"title": "pseudo",
|
|
"id": "d2a6f856-b553-40a0-ac54-a321e8e2da02",
|
|
"status": "Pseudo-Release",
|
|
"medium-list": [
|
|
{
|
|
"track-list": [
|
|
{
|
|
"id": "baz",
|
|
"recording": {
|
|
"title": "translated title",
|
|
"id": "bar",
|
|
"length": 42,
|
|
},
|
|
"position": 9,
|
|
"number": "A1",
|
|
}
|
|
],
|
|
"position": 5,
|
|
}
|
|
],
|
|
"artist-credit": [
|
|
{
|
|
"artist": {
|
|
"name": "some-artist",
|
|
"id": "some-id",
|
|
},
|
|
}
|
|
],
|
|
"release-group": {
|
|
"id": "another-id",
|
|
},
|
|
"release-relation-list": [
|
|
{
|
|
"type": "remaster",
|
|
"target": "d2a6f856-b553-40a0-ac54-a321e8e2da01",
|
|
"direction": "backward",
|
|
}
|
|
],
|
|
}
|
|
},
|
|
]
|
|
|
|
with mock.patch("musicbrainzngs.get_release_by_id") as gp:
|
|
gp.side_effect = side_effect
|
|
album = self.mb.album_for_id("d2a6f856-b553-40a0-ac54-a321e8e2da02")
|
|
assert album.country is None
|
|
|
|
|
|
class TestMusicBrainzPlugin(PluginMixin):
|
|
plugin = "musicbrainz"
|
|
|
|
mbid = "d2a6f856-b553-40a0-ac54-a321e8e2da99"
|
|
RECORDING = {"title": "foo", "id": "bar", "length": 42}
|
|
|
|
@pytest.fixture
|
|
def plugin_config(self):
|
|
return {}
|
|
|
|
@pytest.fixture
|
|
def mb(self, plugin_config):
|
|
self.config[self.plugin].set(plugin_config)
|
|
|
|
return musicbrainz.MusicBrainzPlugin()
|
|
|
|
@pytest.mark.parametrize(
|
|
"plugin_config,va_likely,expected_additional_criteria",
|
|
[
|
|
({}, False, {"artist": "Artist "}),
|
|
({}, True, {"arid": "89ad4ac3-39f7-470e-963a-56509c546377"}),
|
|
(
|
|
{"extra_tags": ["label", "catalognum"]},
|
|
False,
|
|
{"artist": "Artist ", "label": "abc", "catno": "ABC123"},
|
|
),
|
|
],
|
|
)
|
|
def test_get_album_criteria(
|
|
self, mb, va_likely, expected_additional_criteria
|
|
):
|
|
items = [
|
|
Item(catalognum="ABC 123", label="abc"),
|
|
Item(catalognum="ABC 123", label="abc"),
|
|
Item(catalognum="ABC 123", label="def"),
|
|
]
|
|
|
|
assert mb.get_album_criteria(items, "Artist ", " Album", va_likely) == {
|
|
"release": " Album",
|
|
"alias": " Album",
|
|
"tracks": str(len(items)),
|
|
**expected_additional_criteria,
|
|
}
|
|
|
|
def test_item_candidates(self, monkeypatch, mb):
|
|
monkeypatch.setattr(
|
|
"musicbrainzngs.search_recordings",
|
|
lambda *_, **__: {"recording-list": [self.RECORDING]},
|
|
)
|
|
|
|
candidates = list(mb.item_candidates(Item(), "hello", "there"))
|
|
|
|
assert len(candidates) == 1
|
|
assert candidates[0].track_id == self.RECORDING["id"]
|
|
|
|
def test_candidates(self, monkeypatch, mb):
|
|
monkeypatch.setattr(
|
|
"musicbrainzngs.search_releases",
|
|
lambda *_, **__: {"release-list": [{"id": self.mbid}]},
|
|
)
|
|
monkeypatch.setattr(
|
|
"musicbrainzngs.get_release_by_id",
|
|
lambda *_, **__: {
|
|
"release": {
|
|
"title": "hi",
|
|
"id": self.mbid,
|
|
"status": "status",
|
|
"medium-list": [
|
|
{
|
|
"track-list": [
|
|
{
|
|
"id": "baz",
|
|
"recording": self.RECORDING,
|
|
"position": 9,
|
|
"number": "A1",
|
|
}
|
|
],
|
|
"position": 5,
|
|
}
|
|
],
|
|
"artist-credit": [
|
|
{"artist": {"name": "some-artist", "id": "some-id"}}
|
|
],
|
|
"release-group": {"id": "another-id"},
|
|
}
|
|
},
|
|
)
|
|
candidates = list(mb.candidates([], "hello", "there", False))
|
|
|
|
assert len(candidates) == 1
|
|
assert candidates[0].tracks[0].track_id == self.RECORDING["id"]
|
|
assert candidates[0].album == "hi"
|