def test_identical_albums(self):
items = []
items.append(_make_item('one', 1))
items.append(_make_item('two', 2))
items.append(_make_item('three', 3))
info = AlbumInfo(
artist='some artist',
album='some album',
tracks=_make_trackinfo(),
va=False,
album_id=None,
artist_id=None,
)
self.assertEqual(match.distance(items, info), 0)
def test_comp_track_artists_do_not_match(self):
items = []
items.append(self.item('one', 1))
items.append(self.item('two', 2, 'someone else'))
items.append(self.item('three', 3))
info = AlbumInfo(
artist='some artist',
album='some album',
tracks=self.trackinfo(),
va=True,
album_id=None,
artist_id=None,
)
self.assertNotEqual(match.distance(items, info), 0)
def test_global_artists_differ(self):
items = []
items.append(self.item('one', 1))
items.append(self.item('two', 2))
items.append(self.item('three', 3))
info = AlbumInfo(
artist='someone else',
album='some album',
tracks=self.trackinfo(),
va=False,
album_id=None,
artist_id=None,
)
self.assertNotEqual(match.distance(items, info), 0)
def test_comp_track_artists_match(self):
items = []
items.append(self.item('one', 1))
items.append(self.item('two', 2))
items.append(self.item('three', 3))
info = AlbumInfo(
artist='should be ignored',
album='some album',
tracks=self.trackinfo(),
va=True,
album_id=None,
artist_id=None,
)
self.assertEqual(match.distance(items, info), 0)
def test_incomplete_album(self):
items = []
items.append(_make_item('one', 1))
items.append(_make_item('three', 3))
info = AlbumInfo(
artist = 'some artist',
album = 'some album',
tracks = _make_trackinfo(),
va = False,
album_id = None, artist_id = None,
)
self.assertNotEqual(match.distance(items, info), 0)
# Make sure the distance is not too great
self.assertTrue(match.distance(items, info) < 0.2)
def test_tracks_out_of_order(self):
items = []
items.append(_make_item('one', 1))
items.append(_make_item('three', 2))
items.append(_make_item('two', 3))
info = AlbumInfo(
artist = 'some artist',
album = 'some album',
tracks = _make_trackinfo(),
va = False,
album_id = None, artist_id = None,
)
dist = match.distance(items, info)
self.assertTrue(0 < dist < 0.2)
def test_global_artists_differ(self):
items = []
items.append(_make_item(u'one', 1))
items.append(_make_item(u'two', 2))
items.append(_make_item(u'three', 3))
info = AlbumInfo(
artist=u'someone else',
album=u'some album',
tracks=_make_trackinfo(),
va=False,
album_id=None,
artist_id=None,
)
self.assertNotEqual(self._dist(items, info), 0)
def test_comp_track_artists_match(self):
items = []
items.append(_make_item(u'one', 1))
items.append(_make_item(u'two', 2))
items.append(_make_item(u'three', 3))
info = AlbumInfo(
artist=u'should be ignored',
album=u'some album',
tracks=_make_trackinfo(),
va=True,
album_id=None,
artist_id=None,
)
self.assertEqual(self._dist(items, info), 0)
def test_comp_track_artists_do_not_match(self):
items = []
items.append(_make_item(u'one', 1))
items.append(_make_item(u'two', 2, u'someone else'))
items.append(_make_item(u'three', 3))
info = AlbumInfo(
artist=u'some artist',
album=u'some album',
tracks=_make_trackinfo(),
va=True,
album_id=None,
artist_id=None,
)
self.assertNotEqual(self._dist(items, info), 0)
def test_per_medium_track_numbers(self):
items = []
items.append(_make_item(u'one', 1))
items.append(_make_item(u'two', 2))
items.append(_make_item(u'three', 1))
info = AlbumInfo(artist=u'some artist',
album=u'some album',
tracks=_make_trackinfo(),
va=False)
info.tracks[0].medium_index = 1
info.tracks[1].medium_index = 2
info.tracks[2].medium_index = 1
dist = self._dist(items, info)
self.assertEqual(dist, 0)
def test_comp_no_track_artists(self):
# Some VA releases don't have track artists (incomplete metadata).
items = []
items.append(_make_item(u'one', 1))
items.append(_make_item(u'two', 2))
items.append(_make_item(u'three', 3))
info = AlbumInfo(artist=u'should be ignored',
album=u'some album',
tracks=_make_trackinfo(),
va=True)
info.tracks[0].artist = None
info.tracks[1].artist = None
info.tracks[2].artist = None
self.assertEqual(self._dist(items, info), 0)
def _album_task(self, asis, artist=None, album=None, existing=False):
if existing:
item = self.i
else:
item = _common.item()
artist = artist or item.albumartist
album = album or item.album
task = importer.ImportTask(paths=['a path'], toppath='top path',
items=[item])
task.set_candidates(artist, album, None, None)
if asis:
task.set_choice(importer.action.ASIS)
else:
info = AlbumInfo(album, None, artist, None, None)
task.set_choice(AlbumMatch(0, info, {}, set(), set()))
return task
def test_per_medium_track_numbers(self):
items = []
items.append(_make_item('one', 1))
items.append(_make_item('two', 2))
items.append(_make_item('three', 1))
info = AlbumInfo(
artist = 'some artist',
album = 'some album',
tracks = _make_trackinfo(),
va = False,
album_id = None, artist_id = None,
)
info.tracks[0].medium_index = 1
info.tracks[1].medium_index = 2
info.tracks[2].medium_index = 1
dist = match.distance(items, info)
self.assertEqual(dist, 0)
def test_comp_no_track_artists(self):
# Some VA releases don't have track artists (incomplete metadata).
items = []
items.append(self.item('one', 1))
items.append(self.item('two', 2))
items.append(self.item('three', 3))
info = AlbumInfo(
artist='should be ignored',
album='some album',
tracks=self.trackinfo(),
va=True,
album_id=None,
artist_id=None,
)
info.tracks[0].artist = None
info.tracks[1].artist = None
info.tracks[2].artist = None
self.assertEqual(match.distance(items, info), 0)
def test_two_medium_release(self):
items = []
items.append(_make_item('one', 1))
items.append(_make_item('two', 2))
items.append(_make_item('three', 3))
info = AlbumInfo(
artist='some artist',
album='some album',
tracks=_make_trackinfo(),
va=False,
album_id=None,
artist_id=None,
)
info.tracks[0].medium_index = 1
info.tracks[1].medium_index = 2
info.tracks[2].medium_index = 1
dist = self._dist(items, info)
self.assertEqual(dist, 0)
def _album_task(self, asis, artist=None, album=None, existing=False):
if existing:
item = self.i
else:
item = _common.item()
artist = artist or item.albumartist
album = album or item.album
task = importer.ImportTask(path='a path',
toppath='top path',
items=[item])
task.set_match(artist, album, None, None)
if asis:
task.set_choice(importer.action.ASIS)
else:
task.set_choice((AlbumInfo(album, None, artist, None,
None), [item]))
return task
def setUp(self):
self.items = []
self.items.append(Item({}))
self.items.append(Item({}))
trackinfo = []
trackinfo.append(
TrackInfo('oneNew', 'dfa939ec-118c-4d0f-84a0-60f3d1e6522c'))
trackinfo.append(
TrackInfo('twoNew', '40130ed1-a27c-42fd-a328-1ebefb6caef4'))
self.info = AlbumInfo(
tracks=trackinfo,
artist='artistNew',
album='albumNew',
album_id='7edb51cb-77d6-4416-a23c-3a8c2994a2c7',
artist_id='a6623d39-2d8e-4f70-8242-0a9553b91e50',
albumtype='album',
va=False,
)
def setUp(self):
super(ArtImporterTest, self).setUp()
# Mock the album art fetcher to always return our test file.
self.art_file = os.path.join(self.temp_dir, 'tmpcover.jpg')
_common.touch(self.art_file)
self.old_afa = fetchart.art_for_album
self.afa_response = self.art_file
def art_for_album(i, p, maxwidth=None, local_only=False):
return self.afa_response
fetchart.art_for_album = art_for_album
# Test library.
self.libpath = os.path.join(self.temp_dir, 'tmplib.blb')
self.libdir = os.path.join(self.temp_dir, 'tmplib')
os.mkdir(self.libdir)
os.mkdir(os.path.join(self.libdir, 'album'))
itempath = os.path.join(self.libdir, 'album', 'test.mp3')
shutil.copyfile(os.path.join(_common.RSRC, 'full.mp3'), itempath)
self.lib = library.Library(self.libpath)
self.i = _common.item()
self.i.path = itempath
self.album = self.lib.add_album([self.i])
self.lib._connection().commit()
# The plugin and import configuration.
self.plugin = fetchart.FetchArtPlugin()
self.session = _common.import_session(self.lib)
# Import task for the coroutine.
self.task = importer.ImportTask(None, None, [self.i])
self.task.is_album = True
self.task.album = self.album
info = AlbumInfo(
album='some album',
album_id='albumid',
artist='some artist',
artist_id='artistid',
tracks=[],
)
self.task.set_choice(AlbumMatch(0, info, {}, set(), set()))
def _make_album_match(self, artist, album, tracks, distance=0):
if distance:
id = ' ' + 'M' * distance
else:
id = ''
artist = artist.replace('Tag', 'Applied') + id
album = album.replace('Tag', 'Applied') + id
trackInfos = []
for i in range(tracks):
trackInfos.append(self._make_track_match(artist, album, i + 1))
return AlbumInfo(artist=artist,
album=album,
tracks=trackInfos,
va=False,
album_id=u'albumid' + id,
artist_id=u'artistid' + id,
albumtype=u'soundtrack')
def setUp(self):
super(ApplyTest, self).setUp()
self.items = []
self.items.append(Item({}))
self.items.append(Item({}))
trackinfo = []
trackinfo.append(
TrackInfo(
u'oneNew',
'dfa939ec-118c-4d0f-84a0-60f3d1e6522c',
medium=1,
medium_index=1,
medium_total=1,
index=1,
artist_credit='trackArtistCredit',
artist_sort='trackArtistSort',
))
trackinfo.append(
TrackInfo(
u'twoNew',
'40130ed1-a27c-42fd-a328-1ebefb6caef4',
medium=2,
medium_index=1,
index=2,
medium_total=1,
))
self.info = AlbumInfo(
tracks=trackinfo,
artist=u'artistNew',
album=u'albumNew',
album_id='7edb51cb-77d6-4416-a23c-3a8c2994a2c7',
artist_id='a6623d39-2d8e-4f70-8242-0a9553b91e50',
artist_credit=u'albumArtistCredit',
artist_sort=u'albumArtistSort',
albumtype=u'album',
va=False,
mediums=2,
)
def setUp(self):
# Mock the album art fetcher to always return our test file.
self.art_file = os.path.join(_common.RSRC, 'tmpcover.jpg')
_common.touch(self.art_file)
self.old_afa = art.art_for_album
art.art_for_album = lambda a, b: self.art_file
# Test library.
self.libpath = os.path.join(_common.RSRC, 'tmplib.blb')
self.libdir = os.path.join(_common.RSRC, 'tmplib')
os.mkdir(self.libdir)
os.mkdir(os.path.join(self.libdir, 'album'))
itempath = os.path.join(self.libdir, 'album', 'test.mp3')
shutil.copyfile(os.path.join(_common.RSRC, 'full.mp3'), itempath)
self.lib = library.Library(self.libpath)
self.i = _common.item()
self.i.path = itempath
self.album = self.lib.add_album([self.i])
self.lib.save()
# Set up an art-fetching coroutine.
self.config = _common.iconfig(self.lib)
self.config.art = True
self.coro = importer.fetch_art(self.config)
self.coro.next()
# Import task for the coroutine.
self.task = importer.ImportTask(None, None, [self.i])
self.task.is_album = True
self.task.album_id = self.album.id
info = AlbumInfo(
album='some album',
album_id='albumid',
artist='some artist',
artist_id='artistid',
tracks=[TrackInfo('one', 'trackid', 'some artist', 'artistid', 1)],
)
self.task.set_choice((info, [self.i]))
def tag_album(self, items, **kwargs):
artist = (items[0].artist or '') + ' tag'
album = (items[0].album or '') + ' tag'
mapping = {}
dist = Distance()
dist.tracks = {}
for item in items:
title = (item.title or '') + ' tag'
track_info = TrackInfo(title=title, track_id=self.nextid())
mapping[item] = track_info
dist.tracks[track_info] = Distance()
album_info = AlbumInfo(album='album',
album_id=self.nextid(),
artist='artist',
artist_id=self.nextid(),
tracks=mapping.values())
match = AlbumMatch(distance=dist,
info=album_info,
mapping=mapping,
extra_items=[],
extra_tracks=[])
return artist, album, [match], Recommendation.strong
class ApplyTest(_common.TestCase, ApplyTestUtil):
def setUp(self):
super(ApplyTest, self).setUp()
self.items = []
self.items.append(Item({}))
self.items.append(Item({}))
trackinfo = []
trackinfo.append(
TrackInfo(
title=u'oneNew',
track_id=u'dfa939ec-118c-4d0f-84a0-60f3d1e6522c',
medium=1,
medium_index=1,
medium_total=1,
index=1,
artist_credit='trackArtistCredit',
artist_sort='trackArtistSort',
))
trackinfo.append(
TrackInfo(
title=u'twoNew',
track_id=u'40130ed1-a27c-42fd-a328-1ebefb6caef4',
medium=2,
medium_index=1,
index=2,
medium_total=1,
))
self.info = AlbumInfo(
tracks=trackinfo,
artist=u'artistNew',
album=u'albumNew',
album_id='7edb51cb-77d6-4416-a23c-3a8c2994a2c7',
artist_id='a6623d39-2d8e-4f70-8242-0a9553b91e50',
artist_credit=u'albumArtistCredit',
artist_sort=u'albumArtistSort',
albumtype=u'album',
va=False,
mediums=2,
)
def test_titles_applied(self):
self._apply()
self.assertEqual(self.items[0].title, 'oneNew')
self.assertEqual(self.items[1].title, 'twoNew')
def test_album_and_artist_applied_to_all(self):
self._apply()
self.assertEqual(self.items[0].album, 'albumNew')
self.assertEqual(self.items[1].album, 'albumNew')
self.assertEqual(self.items[0].artist, 'artistNew')
self.assertEqual(self.items[1].artist, 'artistNew')
def test_track_index_applied(self):
self._apply()
self.assertEqual(self.items[0].track, 1)
self.assertEqual(self.items[1].track, 2)
def test_track_total_applied(self):
self._apply()
self.assertEqual(self.items[0].tracktotal, 2)
self.assertEqual(self.items[1].tracktotal, 2)
def test_disc_index_applied(self):
self._apply()
self.assertEqual(self.items[0].disc, 1)
self.assertEqual(self.items[1].disc, 2)
def test_disc_total_applied(self):
self._apply()
self.assertEqual(self.items[0].disctotal, 2)
self.assertEqual(self.items[1].disctotal, 2)
def test_per_disc_numbering(self):
self._apply(per_disc_numbering=True)
self.assertEqual(self.items[0].track, 1)
self.assertEqual(self.items[1].track, 1)
def test_per_disc_numbering_track_total(self):
self._apply(per_disc_numbering=True)
self.assertEqual(self.items[0].tracktotal, 1)
self.assertEqual(self.items[1].tracktotal, 1)
def test_artist_credit(self):
self._apply(artist_credit=True)
self.assertEqual(self.items[0].artist, 'trackArtistCredit')
self.assertEqual(self.items[1].artist, 'albumArtistCredit')
self.assertEqual(self.items[0].albumartist, 'albumArtistCredit')
self.assertEqual(self.items[1].albumartist, 'albumArtistCredit')
def test_artist_credit_prefers_artist_over_albumartist_credit(self):
self.info.tracks[0].artist = 'oldArtist'
self.info.tracks[0].artist_credit = None
self._apply(artist_credit=True)
self.assertEqual(self.items[0].artist, 'oldArtist')
def test_artist_credit_falls_back_to_albumartist(self):
self.info.artist_credit = None
self._apply(artist_credit=True)
self.assertEqual(self.items[1].artist, 'artistNew')
def test_mb_trackid_applied(self):
self._apply()
self.assertEqual(self.items[0].mb_trackid,
'dfa939ec-118c-4d0f-84a0-60f3d1e6522c')
self.assertEqual(self.items[1].mb_trackid,
'40130ed1-a27c-42fd-a328-1ebefb6caef4')
def test_mb_albumid_and_artistid_applied(self):
self._apply()
for item in self.items:
self.assertEqual(item.mb_albumid,
'7edb51cb-77d6-4416-a23c-3a8c2994a2c7')
self.assertEqual(item.mb_artistid,
'a6623d39-2d8e-4f70-8242-0a9553b91e50')
def test_albumtype_applied(self):
self._apply()
self.assertEqual(self.items[0].albumtype, 'album')
self.assertEqual(self.items[1].albumtype, 'album')
def test_album_artist_overrides_empty_track_artist(self):
my_info = self.info.copy()
self._apply(info=my_info)
self.assertEqual(self.items[0].artist, 'artistNew')
self.assertEqual(self.items[1].artist, 'artistNew')
def test_album_artist_overridden_by_nonempty_track_artist(self):
my_info = self.info.copy()
my_info.tracks[0].artist = 'artist1!'
my_info.tracks[1].artist = 'artist2!'
self._apply(info=my_info)
self.assertEqual(self.items[0].artist, 'artist1!')
self.assertEqual(self.items[1].artist, 'artist2!')
def test_artist_credit_applied(self):
self._apply()
self.assertEqual(self.items[0].albumartist_credit, 'albumArtistCredit')
self.assertEqual(self.items[0].artist_credit, 'trackArtistCredit')
self.assertEqual(self.items[1].albumartist_credit, 'albumArtistCredit')
self.assertEqual(self.items[1].artist_credit, 'albumArtistCredit')
def test_artist_sort_applied(self):
self._apply()
self.assertEqual(self.items[0].albumartist_sort, 'albumArtistSort')
self.assertEqual(self.items[0].artist_sort, 'trackArtistSort')
self.assertEqual(self.items[1].albumartist_sort, 'albumArtistSort')
self.assertEqual(self.items[1].artist_sort, 'albumArtistSort')
def test_full_date_applied(self):
my_info = self.info.copy()
my_info.year = 2013
my_info.month = 12
my_info.day = 18
self._apply(info=my_info)
self.assertEqual(self.items[0].year, 2013)
self.assertEqual(self.items[0].month, 12)
self.assertEqual(self.items[0].day, 18)
def test_date_only_zeros_month_and_day(self):
self.items = []
self.items.append(Item(year=1, month=2, day=3))
self.items.append(Item(year=4, month=5, day=6))
my_info = self.info.copy()
my_info.year = 2013
self._apply(info=my_info)
self.assertEqual(self.items[0].year, 2013)
self.assertEqual(self.items[0].month, 0)
self.assertEqual(self.items[0].day, 0)
def test_missing_date_applies_nothing(self):
self.items = []
self.items.append(Item(year=1, month=2, day=3))
self.items.append(Item(year=4, month=5, day=6))
self._apply()
self.assertEqual(self.items[0].year, 1)
self.assertEqual(self.items[0].month, 2)
self.assertEqual(self.items[0].day, 3)
def test_data_source_applied(self):
my_info = self.info.copy()
my_info.data_source = 'MusicBrainz'
self._apply(info=my_info)
self.assertEqual(self.items[0].data_source, 'MusicBrainz')
class ApplyCompilationTest(_common.TestCase, ApplyTestUtil):
def setUp(self):
super(ApplyCompilationTest, self).setUp()
self.items = []
self.items.append(Item({}))
self.items.append(Item({}))
trackinfo = []
trackinfo.append(
TrackInfo(
title=u'oneNew',
track_id=u'dfa939ec-118c-4d0f-84a0-60f3d1e6522c',
artist=u'artistOneNew',
artist_id=u'a05686fc-9db2-4c23-b99e-77f5db3e5282',
index=1,
))
trackinfo.append(
TrackInfo(
title=u'twoNew',
track_id=u'40130ed1-a27c-42fd-a328-1ebefb6caef4',
artist=u'artistTwoNew',
artist_id=u'80b3cf5e-18fe-4c59-98c7-e5bb87210710',
index=2,
))
self.info = AlbumInfo(
tracks=trackinfo,
artist=u'variousNew',
album=u'albumNew',
album_id='3b69ea40-39b8-487f-8818-04b6eff8c21a',
artist_id='89ad4ac3-39f7-470e-963a-56509c546377',
albumtype=u'compilation',
)
def test_album_and_track_artists_separate(self):
self._apply()
self.assertEqual(self.items[0].artist, 'artistOneNew')
self.assertEqual(self.items[1].artist, 'artistTwoNew')
self.assertEqual(self.items[0].albumartist, 'variousNew')
self.assertEqual(self.items[1].albumartist, 'variousNew')
def test_mb_albumartistid_applied(self):
self._apply()
self.assertEqual(self.items[0].mb_albumartistid,
'89ad4ac3-39f7-470e-963a-56509c546377')
self.assertEqual(self.items[1].mb_albumartistid,
'89ad4ac3-39f7-470e-963a-56509c546377')
self.assertEqual(self.items[0].mb_artistid,
'a05686fc-9db2-4c23-b99e-77f5db3e5282')
self.assertEqual(self.items[1].mb_artistid,
'80b3cf5e-18fe-4c59-98c7-e5bb87210710')
def test_va_flag_cleared_does_not_set_comp(self):
self._apply()
self.assertFalse(self.items[0].comp)
self.assertFalse(self.items[1].comp)
def test_va_flag_sets_comp(self):
va_info = self.info.copy()
va_info.va = True
self._apply(info=va_info)
self.assertTrue(self.items[0].comp)
self.assertTrue(self.items[1].comp)
def test_main_interface_returns_none_for_missing_asin_and_path(self):
album = AlbumInfo(None, None, None, None, None, asin=None)
artpath = art.art_for_album(album, None)
self.assertEqual(artpath, None)
def album_for_id(self, album_id):
"""Fetch an album by its Deezer ID or URL and return an
AlbumInfo object or None if the album is not found.
:param album_id: Deezer ID or URL for the album.
:type album_id: str
:return: AlbumInfo object for album.
:rtype: beets.autotag.hooks.AlbumInfo or None
"""
deezer_id = self._get_id('album', album_id)
if deezer_id is None:
return None
album_data = requests.get(self.album_url + deezer_id).json()
artist, artist_id = self.get_artist(album_data['contributors'])
release_date = album_data['release_date']
date_parts = [int(part) for part in release_date.split('-')]
num_date_parts = len(date_parts)
if num_date_parts == 3:
year, month, day = date_parts
elif num_date_parts == 2:
year, month = date_parts
day = None
elif num_date_parts == 1:
year = date_parts[0]
month = None
day = None
else:
raise ui.UserError(u"Invalid `release_date` returned "
u"by {} API: '{}'".format(
self.data_source, release_date))
tracks_data = requests.get(self.album_url + deezer_id +
'/tracks').json()['data']
tracks = []
medium_totals = collections.defaultdict(int)
for i, track_data in enumerate(tracks_data, start=1):
track = self._get_track(track_data)
track.index = i
medium_totals[track.medium] += 1
tracks.append(track)
for track in tracks:
track.medium_total = medium_totals[track.medium]
return AlbumInfo(
album=album_data['title'],
album_id=deezer_id,
artist=artist,
artist_credit=self.get_artist([album_data['artist']])[0],
artist_id=artist_id,
tracks=tracks,
albumtype=album_data['record_type'],
va=len(album_data['contributors']) == 1
and artist.lower() == 'various artists',
year=year,
month=month,
day=day,
label=album_data['label'],
mediums=max(medium_totals.keys()),
data_source=self.data_source,
data_url=album_data['link'],
)
def test_main_interface_gives_precedence_to_fs_art(self):
_common.touch(os.path.join(self.dpath, 'a.jpg'))
art.urllib.urlretrieve = MockUrlRetrieve('anotherpath', 'image/jpeg')
album = AlbumInfo(None, None, None, None, None, asin='xxxx')
artpath = art.art_for_album(album, self.dpath)
self.assertEqual(artpath, os.path.join(self.dpath, 'a.jpg'))
def test_main_interface_tries_amazon_before_aao(self):
self.urlopen_called = False
art.urllib.urlretrieve = MockUrlRetrieve('anotherpath', 'image/jpeg')
album = AlbumInfo(None, None, None, None, None, asin='xxxx')
art.art_for_album(album, self.dpath)
self.assertFalse(self.urlopen_called)
def test_main_interface_falls_back_to_aao(self):
self.urlopen_called = False
art.urllib.urlretrieve = MockUrlRetrieve('anotherpath', 'text/html')
album = AlbumInfo(None, None, None, None, None, asin='xxxx')
art.art_for_album(album, self.dpath)
self.assertTrue(self.urlopen_called)
def test_main_interface_returns_amazon_art(self):
art.urllib.urlretrieve = MockUrlRetrieve('anotherpath', 'image/jpeg')
album = AlbumInfo(None, None, None, None, None, asin='xxxx')
artpath = art.art_for_album(album, None)
self.assertEqual(artpath, 'anotherpath')
