def test_eq(self, lib_mock):
sp_artist = spotify.ffi.cast('sp_artist *', 42)
artist1 = spotify.Artist(self.session, sp_artist=sp_artist)
artist2 = spotify.Artist(self.session, sp_artist=sp_artist)
self.assertTrue(artist1 == artist2)
self.assertFalse(artist1 == 'foo')
def test_create_from_uri(self, link_mock, lib_mock):
sp_artist = spotify.ffi.new('int *')
link_instance_mock = link_mock.return_value
link_instance_mock.as_artist.return_value = spotify.Artist(
sp_artist=sp_artist)
lib_mock.sp_link_as_artist.return_value = sp_artist
uri = 'spotify:artist:foo'
result = spotify.Artist(uri)
link_mock.assert_called_with(uri)
link_instance_mock.as_artist.assert_called_with()
lib_mock.sp_artist_add_ref.assert_called_with(sp_artist)
self.assertEqual(result._sp_artist, sp_artist)
def test_browser_is_gone_before_callback_is_called(self, lib_mock):
tests.create_session()
sp_artist = spotify.ffi.new('int *')
artist = spotify.Artist(sp_artist=sp_artist)
sp_artistbrowse = spotify.ffi.cast('sp_artistbrowse *',
spotify.ffi.new('int *'))
lib_mock.sp_artistbrowse_create.return_value = sp_artistbrowse
callback = mock.Mock()
result = spotify.ArtistBrowser(artist=artist, callback=callback)
complete_event = result.complete_event
result = None # noqa
tests.gc_collect()
# FIXME The mock keeps the handle/userdata alive, thus the artist is
# kept alive, and this test doesn't test what it is intended to test.
artistbrowse_complete_cb = (
lib_mock.sp_artistbrowse_create.call_args[0][3])
userdata = lib_mock.sp_artistbrowse_create.call_args[0][4]
artistbrowse_complete_cb(sp_artistbrowse, userdata)
complete_event.wait(3)
self.assertEqual(callback.call_count, 1)
self.assertEqual(callback.call_args[0][0]._sp_artistbrowse,
sp_artistbrowse)
def test_browser_is_gone_before_callback_is_called(self, lib_mock):
sp_artist = spotify.ffi.cast('sp_artist *', 43)
artist = spotify.Artist(self.session, sp_artist=sp_artist)
sp_artistbrowse = spotify.ffi.cast('sp_artistbrowse *', 42)
lib_mock.sp_artistbrowse_create.return_value = sp_artistbrowse
callback = mock.Mock()
result = spotify.ArtistBrowser(self.session,
artist=artist,
callback=callback)
loaded_event = result.loaded_event
result = None # noqa
tests.gc_collect()
# The mock keeps the handle/userdata alive, thus this test doesn't
# really test that session._callback_handles keeps the handle alive.
artistbrowse_complete_cb = lib_mock.sp_artistbrowse_create.call_args[
0][3]
userdata = lib_mock.sp_artistbrowse_create.call_args[0][4]
artistbrowse_complete_cb(sp_artistbrowse, userdata)
loaded_event.wait(3)
self.assertEqual(callback.call_count, 1)
self.assertEqual(callback.call_args[0][0]._sp_artistbrowse,
sp_artistbrowse)
def test_portrait(self, image_mock, lib_mock):
sp_artist = spotify.ffi.cast('sp_artist *', 42)
artist = spotify.Artist(self.session, sp_artist=sp_artist)
sp_image_id = spotify.ffi.new('char[]', b'portrait-id')
lib_mock.sp_artist_portrait.return_value = sp_image_id
sp_image = spotify.ffi.cast('sp_image *', 43)
lib_mock.sp_image_create.return_value = sp_image
image_mock.return_value = mock.sentinel.image
image_size = spotify.ImageSize.SMALL
callback = mock.Mock()
result = artist.portrait(image_size, callback=callback)
self.assertIs(result, mock.sentinel.image)
lib_mock.sp_artist_portrait.assert_called_with(sp_artist,
int(image_size))
lib_mock.sp_image_create.assert_called_with(self.session._sp_session,
sp_image_id)
# Since we *created* the sp_image, we already have a refcount of 1 and
# shouldn't increase the refcount when wrapping this sp_image in an
# Image object
image_mock.assert_called_with(self.session,
sp_image=sp_image,
add_ref=False,
callback=callback)
def test_load(self, load_mock, lib_mock):
sp_artist = spotify.ffi.cast('sp_artist *', 42)
artist = spotify.Artist(self.session, sp_artist=sp_artist)
artist.load(10)
load_mock.assert_called_with(self.session, artist, timeout=10)
def test_load(self, load_mock, lib_mock):
sp_artist = spotify.ffi.new('int *')
artist = spotify.Artist(sp_artist=sp_artist)
artist.load(10)
load_mock.assert_called_with(artist, timeout=10)
def test_releases_sp_artist_when_artist_dies(self, lib_mock):
sp_artist = spotify.ffi.cast('sp_artist *', 42)
artist = spotify.Artist(self.session, sp_artist=sp_artist)
artist = None # noqa
tests.gc_collect()
lib_mock.sp_artist_release.assert_called_with(sp_artist)
def test_create_from_uri_fail_raises_error(self, link_mock, lib_mock):
link_instance_mock = link_mock.return_value
link_instance_mock.as_artist.return_value = None
lib_mock.sp_link_as_artist.return_value = spotify.ffi.NULL
uri = 'spotify:artist:foo'
with self.assertRaises(ValueError):
spotify.Artist(uri)
def test_releases_sp_artist_when_artist_dies(self, lib_mock):
sp_artist = spotify.ffi.new('int *')
artist = spotify.Artist(sp_artist=sp_artist)
artist = None # noqa
tests.gc_collect()
lib_mock.sp_artist_release.assert_called_with(sp_artist)
def test_is_loaded(self, lib_mock):
lib_mock.sp_artist_is_loaded.return_value = 1
sp_artist = spotify.ffi.cast('sp_artist *', 42)
artist = spotify.Artist(self.session, sp_artist=sp_artist)
result = artist.is_loaded
lib_mock.sp_artist_is_loaded.assert_called_once_with(sp_artist)
self.assertTrue(result)
def artist(self):
"""The artist of the album.
Will always return :class:`None` if the album isn't loaded.
"""
sp_artist = lib.sp_album_artist(self._sp_album)
if sp_artist == ffi.NULL:
return None
return spotify.Artist(self._session, sp_artist=sp_artist, add_ref=True)
def test_is_loaded(self, lib_mock):
lib_mock.sp_artist_is_loaded.return_value = 1
sp_artist = spotify.ffi.new('int *')
artist = spotify.Artist(sp_artist=sp_artist)
result = artist.is_loaded
lib_mock.sp_artist_is_loaded.assert_called_once_with(sp_artist)
self.assertTrue(result)
def test_repr(self, link_mock, lib_mock):
link_instance_mock = link_mock.return_value
link_instance_mock.uri = 'foo'
sp_artist = spotify.ffi.new('int *')
artist = spotify.Artist(sp_artist=sp_artist)
result = repr(artist)
self.assertEqual(result, 'Artist(%r)' % 'foo')
def test_name_is_none_if_unloaded(self, lib_mock):
lib_mock.sp_artist_name.return_value = spotify.ffi.new('char[]', b'')
sp_artist = spotify.ffi.new('int *')
artist = spotify.Artist(sp_artist=sp_artist)
result = artist.name
lib_mock.sp_artist_name.assert_called_once_with(sp_artist)
self.assertIsNone(result)
def test_name(self, lib_mock):
lib_mock.sp_artist_name.return_value = spotify.ffi.new(
'char[]', b'Foo Bar Baz')
sp_artist = spotify.ffi.new('int *')
artist = spotify.Artist(sp_artist=sp_artist)
result = artist.name
lib_mock.sp_artist_name.assert_called_once_with(sp_artist)
self.assertEqual(result, 'Foo Bar Baz')
def test_portrait_is_none_if_null(self, lib_mock):
lib_mock.sp_artist_portrait.return_value = spotify.ffi.NULL
sp_artist = spotify.ffi.new('int *')
artist = spotify.Artist(sp_artist=sp_artist)
result = artist.portrait()
lib_mock.sp_artist_portrait.assert_called_with(
sp_artist, int(spotify.ImageSize.NORMAL))
self.assertIsNone(result)
def test_portrait_link_defaults_to_normal_size(self, link_mock, lib_mock):
sp_artist = spotify.ffi.cast('sp_artist *', 42)
artist = spotify.Artist(self.session, sp_artist=sp_artist)
sp_link = spotify.ffi.cast('sp_link *', 43)
lib_mock.sp_link_create_from_artist_portrait.return_value = sp_link
link_mock.return_value = mock.sentinel.link
artist.portrait_link()
lib_mock.sp_link_create_from_artist_portrait.assert_called_once_with(
sp_artist, int(spotify.ImageSize.NORMAL))
def test_link_creates_link_to_artist(self, link_mock, lib_mock):
sp_artist = spotify.ffi.new('int *')
artist = spotify.Artist(sp_artist=sp_artist)
sp_link = spotify.ffi.new('int *')
lib_mock.sp_link_create_from_artist.return_value = sp_link
link_mock.return_value = mock.sentinel.link
result = artist.link
link_mock.assert_called_once_with(sp_link=sp_link, add_ref=False)
self.assertEqual(result, mock.sentinel.link)
def test_portrait_defaults_to_normal_size(self, image_mock, lib_mock):
sp_image_id = spotify.ffi.new('char[]', b'portrait-id')
lib_mock.sp_artist_portrait.return_value = sp_image_id
sp_image = spotify.ffi.cast('sp_image *', 43)
lib_mock.sp_image_create.return_value = sp_image
sp_artist = spotify.ffi.cast('sp_artist *', 42)
artist = spotify.Artist(self.session, sp_artist=sp_artist)
artist.portrait()
lib_mock.sp_artist_portrait.assert_called_with(
sp_artist, int(spotify.ImageSize.NORMAL))
def get_artist(self, uri):
"""
Get :class:`Artist` from a Spotify artist URI.
Example::
>>> session = spotify.Session()
# ...
>>> artist = session.get_artist(
... 'spotify:artist:22xRIphSN7IkPVbErICu7s')
>>> artist.load().name
u'Rob Dougan'
"""
return spotify.Artist(self, uri=uri)
def test_portrait_link_creates_link_to_portrait(self, link_mock, lib_mock):
sp_artist = spotify.ffi.cast('sp_artist *', 42)
artist = spotify.Artist(self.session, sp_artist=sp_artist)
sp_link = spotify.ffi.cast('sp_link *', 43)
lib_mock.sp_link_create_from_artist_portrait.return_value = sp_link
link_mock.return_value = mock.sentinel.link
image_size = spotify.ImageSize.SMALL
result = artist.portrait_link(image_size)
lib_mock.sp_link_create_from_artist_portrait.assert_called_once_with(
sp_artist, int(image_size))
link_mock.assert_called_once_with(self.session,
sp_link=sp_link,
add_ref=False)
self.assertEqual(result, mock.sentinel.link)
def test_create_from_artist(self, lib_mock):
sp_artist = spotify.ffi.cast('sp_artist *', 43)
artist = spotify.Artist(self.session, sp_artist=sp_artist)
sp_artistbrowse = spotify.ffi.cast('sp_artistbrowse *', 42)
lib_mock.sp_artistbrowse_create.return_value = sp_artistbrowse
result = artist.browse()
lib_mock.sp_artistbrowse_create.assert_called_with(
self.session._sp_session, sp_artist,
int(spotify.ArtistBrowserType.FULL), mock.ANY, mock.ANY)
self.assertIsInstance(result, spotify.ArtistBrowser)
artistbrowse_complete_cb = (
lib_mock.sp_artistbrowse_create.call_args[0][3])
userdata = lib_mock.sp_artistbrowse_create.call_args[0][4]
self.assertFalse(result.loaded_event.is_set())
artistbrowse_complete_cb(sp_artistbrowse, userdata)
self.assertTrue(result.loaded_event.is_set())
def test_create_from_artist_with_type_and_callback(self, lib_mock):
sp_artist = spotify.ffi.cast('sp_artist *', 43)
artist = spotify.Artist(self.session, sp_artist=sp_artist)
sp_artistbrowse = spotify.ffi.cast('sp_artistbrowse *', 42)
lib_mock.sp_artistbrowse_create.return_value = sp_artistbrowse
callback = mock.Mock()
result = artist.browse(type=spotify.ArtistBrowserType.NO_TRACKS,
callback=callback)
lib_mock.sp_artistbrowse_create.assert_called_with(
self.session._sp_session, sp_artist,
int(spotify.ArtistBrowserType.NO_TRACKS), mock.ANY, mock.ANY)
artistbrowse_complete_cb = (
lib_mock.sp_artistbrowse_create.call_args[0][3])
userdata = lib_mock.sp_artistbrowse_create.call_args[0][4]
artistbrowse_complete_cb(sp_artistbrowse, userdata)
result.loaded_event.wait(3)
callback.assert_called_with(result)
def test_portrait(self, image_lib_mock, lib_mock):
session = tests.create_session()
sp_image_id = spotify.ffi.new('char[]', b'portrait-id')
lib_mock.sp_artist_portrait.return_value = sp_image_id
sp_image = spotify.ffi.new('int *')
lib_mock.sp_image_create.return_value = sp_image
sp_artist = spotify.ffi.new('int *')
artist = spotify.Artist(sp_artist=sp_artist)
image_size = spotify.ImageSize.SMALL
result = artist.portrait(image_size)
lib_mock.sp_artist_portrait.assert_called_with(sp_artist,
int(image_size))
lib_mock.sp_image_create.assert_called_with(session._sp_session,
sp_image_id)
self.assertIsInstance(result, spotify.Image)
self.assertEqual(result._sp_image, sp_image)
# Since we *created* the sp_image, we already have a refcount of 1 and
# shouldn't increase the refcount when wrapping this sp_image in an
# Image object
self.assertEqual(image_lib_mock.sp_image_add_ref.call_count, 0)
def test_adds_ref_to_sp_artist_when_created(self, lib_mock):
sp_artist = spotify.ffi.new('int *')
spotify.Artist(sp_artist=sp_artist)
lib_mock.sp_artist_add_ref.assert_called_with(sp_artist)
def get_artist(sp_track, key):
return spotify.Artist(
self._session,
sp_artist=lib.sp_track_artist(sp_track, key),
add_ref=True,
)
def test_create_without_uri_or_sp_artist_fails(self, lib_mock):
with self.assertRaises(AssertionError):
spotify.Artist()
def get_artist(sp_track, key):
return spotify.Artist(sp_artist=lib.sp_track_artist(sp_track, key),
add_ref=True)
def get_artist(sp_artistbrowse, key):
return spotify.Artist(self._session,
sp_artist=lib.sp_artistbrowse_similar_artist(
sp_artistbrowse, key),
add_ref=True)
