def test_eq(self, lib_mock):
sp_album = spotify.ffi.cast('sp_album *', 42)
album1 = spotify.Album(self.session, sp_album=sp_album)
album2 = spotify.Album(self.session, sp_album=sp_album)
self.assertTrue(album1 == album2)
self.assertFalse(album1 == 'foo')
def test_create_from_uri(self, link_mock, lib_mock):
sp_album = spotify.ffi.new('int *')
link_instance_mock = link_mock.return_value
link_instance_mock.as_album.return_value = spotify.Album(
sp_album=sp_album)
uri = 'spotify:album:foo'
result = spotify.Album(uri)
link_mock.assert_called_with(uri)
link_instance_mock.as_album.assert_called_with()
lib_mock.sp_album_add_ref.assert_called_with(sp_album)
self.assertEqual(result._sp_album, sp_album)
def test_cover(self, image_mock, lib_mock):
sp_album = spotify.ffi.cast('sp_album *', 42)
album = spotify.Album(self.session, sp_album=sp_album)
sp_image_id = spotify.ffi.new('char[]', b'cover-id')
lib_mock.sp_album_cover.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 = album.cover(image_size, callback=callback)
self.assertIs(result, mock.sentinel.image)
lib_mock.sp_album_cover.assert_called_with(sp_album, 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_create_from_uri_fail_raises_error(self, link_mock, lib_mock):
link_instance_mock = link_mock.return_value
link_instance_mock.as_album.return_value = None
uri = 'spotify:album:foo'
with self.assertRaises(ValueError):
spotify.Album(uri)
def test_load(self, load_mock, lib_mock):
sp_album = spotify.ffi.cast('sp_album *', 42)
album = spotify.Album(self.session, sp_album=sp_album)
album.load(10)
load_mock.assert_called_with(self.session, album, timeout=10)
def test_browser_is_gone_before_callback_is_called(self, lib_mock):
tests.create_session()
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
sp_albumbrowse = spotify.ffi.cast('sp_albumbrowse *',
spotify.ffi.new('int *'))
lib_mock.sp_albumbrowse_create.return_value = sp_albumbrowse
callback = mock.Mock()
result = spotify.AlbumBrowser(album=album, callback=callback)
complete_event = result.complete_event
result = None # noqa
tests.gc_collect()
# FIXME The mock keeps the handle/userdata alive, thus the album is
# kept alive, and this test doesn't test what it is intended to test.
albumbrowse_complete_cb = (
lib_mock.sp_albumbrowse_create.call_args[0][2])
userdata = lib_mock.sp_albumbrowse_create.call_args[0][3]
albumbrowse_complete_cb(sp_albumbrowse, userdata)
complete_event.wait(3)
self.assertEqual(callback.call_count, 1)
self.assertEqual(callback.call_args[0][0]._sp_albumbrowse,
sp_albumbrowse)
def test_browser_is_gone_before_callback_is_called(self, lib_mock):
sp_album = spotify.ffi.cast('sp_album *', 43)
album = spotify.Album(self.session, sp_album=sp_album)
sp_albumbrowse = spotify.ffi.cast('sp_albumbrowse *', 42)
lib_mock.sp_albumbrowse_create.return_value = sp_albumbrowse
callback = mock.Mock()
result = spotify.AlbumBrowser(self.session,
album=album,
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.
albumbrowse_complete_cb = (
lib_mock.sp_albumbrowse_create.call_args[0][2])
userdata = lib_mock.sp_albumbrowse_create.call_args[0][3]
albumbrowse_complete_cb(sp_albumbrowse, userdata)
loaded_event.wait(3)
self.assertEqual(callback.call_count, 1)
self.assertEqual(callback.call_args[0][0]._sp_albumbrowse,
sp_albumbrowse)
def test_load(self, load_mock, lib_mock):
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
album.load(10)
load_mock.assert_called_with(album, timeout=10)
def test_releases_sp_album_when_album_dies(self, lib_mock):
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
album = None # noqa
tests.gc_collect()
lib_mock.sp_album_release.assert_called_with(sp_album)
def test_releases_sp_album_when_album_dies(self, lib_mock):
sp_album = spotify.ffi.cast('sp_album *', 42)
album = spotify.Album(self.session, sp_album=sp_album)
album = None # noqa
tests.gc_collect()
lib_mock.sp_album_release.assert_called_with(sp_album)
def test_type(self, lib_mock):
lib_mock.sp_album_type.return_value = int(spotify.AlbumType.SINGLE)
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
result = album.type
lib_mock.sp_album_type.assert_called_once_with(sp_album)
self.assertIs(result, spotify.AlbumType.SINGLE)
def test_year(self, lib_mock):
lib_mock.sp_album_year.return_value = 2013
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
result = album.year
lib_mock.sp_album_year.assert_called_once_with(sp_album)
self.assertEqual(result, 2013)
def test_is_available_is_none_if_unloaded(self, lib_mock):
lib_mock.sp_album_is_loaded.return_value = 0
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
result = album.is_available
lib_mock.sp_album_is_loaded.assert_called_once_with(sp_album)
self.assertIsNone(result)
def test_name_is_none_if_unloaded(self, lib_mock):
lib_mock.sp_album_name.return_value = spotify.ffi.new('char[]', b'')
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
result = album.name
lib_mock.sp_album_name.assert_called_once_with(sp_album)
self.assertIsNone(result)
def test_artist_if_unloaded(self, artist_lib_mock, lib_mock):
lib_mock.sp_album_artist.return_value = spotify.ffi.NULL
sp_album = spotify.ffi.cast('sp_album *', 42)
album = spotify.Album(self.session, sp_album=sp_album)
result = album.artist
lib_mock.sp_album_artist.assert_called_with(sp_album)
self.assertIsNone(result)
def test_type_is_none_if_unloaded(self, lib_mock):
lib_mock.sp_album_is_loaded.return_value = 0
sp_album = spotify.ffi.cast('sp_album *', 42)
album = spotify.Album(self.session, sp_album=sp_album)
result = album.type
lib_mock.sp_album_is_loaded.assert_called_once_with(sp_album)
self.assertIsNone(result)
def test_is_loaded(self, lib_mock):
lib_mock.sp_album_is_loaded.return_value = 1
sp_album = spotify.ffi.cast('sp_album *', 42)
album = spotify.Album(self.session, sp_album=sp_album)
result = album.is_loaded
lib_mock.sp_album_is_loaded.assert_called_once_with(sp_album)
self.assertTrue(result)
def test_is_available(self, lib_mock):
lib_mock.sp_album_is_available.return_value = 1
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
result = album.is_available
lib_mock.sp_album_is_available.assert_called_once_with(sp_album)
self.assertTrue(result)
def test_repr(self, link_mock, lib_mock):
link_instance_mock = link_mock.return_value
link_instance_mock.uri = 'foo'
sp_album = spotify.ffi.cast('sp_album *', 42)
album = spotify.Album(self.session, sp_album=sp_album)
result = repr(album)
self.assertEqual(result, 'Album(%r)' % 'foo')
def test_repr(self, link_mock, lib_mock):
link_instance_mock = link_mock.return_value
link_instance_mock.uri = 'foo'
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
result = repr(album)
self.assertEqual(result, 'Album(%r)' % 'foo')
def test_artist_if_unloaded(self, artist_lib_mock, lib_mock):
lib_mock.sp_album_artist.return_value = spotify.ffi.NULL
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
result = album.artist
lib_mock.sp_album_artist.assert_called_with(sp_album)
self.assertIsNone(result)
def test_year(self, lib_mock):
lib_mock.sp_album_year.return_value = 2013
sp_album = spotify.ffi.cast('sp_album *', 42)
album = spotify.Album(self.session, sp_album=sp_album)
result = album.year
lib_mock.sp_album_year.assert_called_once_with(sp_album)
self.assertEqual(result, 2013)
def album(self):
"""The album of the track.
Will always return :class:`None` if the track isn't loaded.
"""
spotify.Error.maybe_raise(self.error)
sp_album = lib.sp_track_album(self._sp_track)
if sp_album == ffi.NULL:
return None
return spotify.Album(sp_album=sp_album, add_ref=True)
def test_name(self, lib_mock):
lib_mock.sp_album_name.return_value = spotify.ffi.new(
'char[]', b'Foo Bar Baz')
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
result = album.name
lib_mock.sp_album_name.assert_called_once_with(sp_album)
self.assertEqual(result, 'Foo Bar Baz')
def test_cover_is_none_if_null(self, lib_mock):
lib_mock.sp_album_cover.return_value = spotify.ffi.NULL
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
result = album.cover()
lib_mock.sp_album_cover.assert_called_with(
sp_album, int(spotify.ImageSize.NORMAL))
self.assertIsNone(result)
def album(self):
"""The album of the track.
Will always return :class:`None` if the track isn't loaded.
"""
spotify.Error.maybe_raise(self.error,
ignores=[spotify.ErrorType.IS_LOADING])
if not self.is_loaded:
return None
sp_album = lib.sp_track_album(self._sp_track)
return spotify.Album(self._session, sp_album=sp_album, add_ref=True)
def test_cover_link_defaults_to_normal_size(self, link_mock, lib_mock):
sp_album = spotify.ffi.cast('sp_album *', 42)
album = spotify.Album(self.session, sp_album=sp_album)
sp_link = spotify.ffi.cast('sp_link *', 43)
lib_mock.sp_link_create_from_album_cover.return_value = sp_link
link_mock.return_value = mock.sentinel.link
album.cover_link()
lib_mock.sp_link_create_from_album_cover.assert_called_once_with(
sp_album, int(spotify.ImageSize.NORMAL))
def test_link_creates_link_to_album(self, link_mock, lib_mock):
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
sp_link = spotify.ffi.new('int *')
lib_mock.sp_link_create_from_album.return_value = sp_link
link_mock.return_value = mock.sentinel.link
result = album.link
link_mock.assert_called_once_with(sp_link=sp_link, add_ref=False)
self.assertEqual(result, mock.sentinel.link)
def test_cover_defaults_to_normal_size(self, image_mock, lib_mock):
sp_image_id = spotify.ffi.new('char[]', b'cover-id')
lib_mock.sp_album_cover.return_value = sp_image_id
sp_image = spotify.ffi.cast('sp_image *', 43)
lib_mock.sp_image_create.return_value = sp_image
sp_album = spotify.ffi.cast('sp_album *', 42)
album = spotify.Album(self.session, sp_album=sp_album)
album.cover()
lib_mock.sp_album_cover.assert_called_with(
sp_album, int(spotify.ImageSize.NORMAL))
def test_artist(self, artist_lib_mock, lib_mock):
sp_artist = spotify.ffi.new('int *')
lib_mock.sp_album_artist.return_value = sp_artist
sp_album = spotify.ffi.new('int *')
album = spotify.Album(sp_album=sp_album)
result = album.artist
lib_mock.sp_album_artist.assert_called_with(sp_album)
self.assertEqual(artist_lib_mock.sp_artist_add_ref.call_count, 1)
self.assertIsInstance(result, spotify.Artist)
self.assertEqual(result._sp_artist, sp_artist)
