def test_inbox_post_where_result_is_gone_before_callback_is_called(
self, track_lib_mock, lib_mock):
sp_track1 = spotify.ffi.cast('sp_track *', 43)
track1 = spotify.Track(self.session, sp_track=sp_track1)
sp_track2 = spotify.ffi.cast('sp_track *', 44)
track2 = spotify.Track(self.session, sp_track=sp_track2)
sp_inbox = spotify.ffi.cast('sp_inbox *', 42)
lib_mock.sp_inbox_post_tracks.return_value = sp_inbox
callback = mock.Mock()
result = spotify.InboxPostResult(self.session,
'alice', [track1, track2],
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.
inboxpost_complete_cb = lib_mock.sp_inbox_post_tracks.call_args[0][5]
userdata = lib_mock.sp_inbox_post_tracks.call_args[0][6]
inboxpost_complete_cb(sp_inbox, userdata)
loaded_event.wait(3)
self.assertEqual(callback.call_count, 1)
self.assertEqual(callback.call_args[0][0]._sp_inbox, sp_inbox)
def test_inbox_post_where_result_is_gone_before_callback_is_called(
self, track_lib_mock, lib_mock):
tests.create_session()
sp_track1 = spotify.ffi.new('int *')
track1 = spotify.Track(sp_track=sp_track1)
sp_track2 = spotify.ffi.new('int *')
track2 = spotify.Track(sp_track=sp_track2)
sp_inbox = spotify.ffi.cast('sp_inbox *', spotify.ffi.new('int *'))
lib_mock.sp_inbox_post_tracks.return_value = sp_inbox
callback = mock.Mock()
result = spotify.InboxPostResult('alice', [track1, track2],
callback=callback)
complete_event = result.complete_event
result = None # noqa
tests.gc_collect()
# FIXME The mock keeps the handle/userdata alive, thus the search
# result is kept alive, and this test doesn't test what it is intended
# to test.
inboxpost_complete_cb = lib_mock.sp_inbox_post_tracks.call_args[0][5]
userdata = lib_mock.sp_inbox_post_tracks.call_args[0][6]
inboxpost_complete_cb(sp_inbox, userdata)
complete_event.wait(3)
self.assertEqual(callback.call_count, 1)
self.assertEqual(callback.call_args[0][0]._sp_inbox, sp_inbox)
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_toplist_is_gone_before_callback_is_called(self, lib_mock):
sp_toplistbrowse = spotify.ffi.cast('sp_toplistbrowse *', 42)
lib_mock.sp_toplistbrowse_create.return_value = sp_toplistbrowse
callback = mock.Mock()
result = spotify.Toplist(
self.session,
type=spotify.ToplistType.TRACKS,
region=spotify.ToplistRegion.USER,
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.
toplistbrowse_complete_cb = lib_mock.sp_toplistbrowse_create.call_args[
0][4]
userdata = lib_mock.sp_toplistbrowse_create.call_args[0][5]
toplistbrowse_complete_cb(sp_toplistbrowse, userdata)
loaded_event.wait(3)
self.assertEqual(callback.call_count, 1)
self.assertEqual(callback.call_args[0][0]._sp_toplistbrowse,
sp_toplistbrowse)
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_create_with_callback_and_throw_away_image_and_call_load_callback(
self, lib_mock):
lib_mock.sp_image_add_load_callback.return_value = int(
spotify.ErrorType.OK)
lib_mock.sp_image_remove_load_callback.return_value = int(
spotify.ErrorType.OK)
sp_image = spotify.ffi.cast('sp_image *', 42)
lib_mock.sp_image_create.return_value = sp_image
callback = mock.Mock()
# Add callback
image = spotify.Image(self.session,
sp_image=sp_image,
callback=callback)
loaded_event = image.loaded_event
# Throw away reference to 'image'
image = 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.
# Call callback
image_load_cb = lib_mock.sp_image_add_load_callback.call_args[0][1]
callback_handle = lib_mock.sp_image_add_load_callback.call_args[0][2]
image_load_cb(sp_image, callback_handle)
loaded_event.wait(3)
self.assertEqual(callback.call_count, 1)
self.assertEqual(callback.call_args[0][0]._sp_image, sp_image)
def test_releases_sp_search_when_search_dies(self, lib_mock):
sp_search = spotify.ffi.new('int *')
search = spotify.Search(sp_search=sp_search)
search = None # noqa
tests.gc_collect()
lib_mock.sp_search_release.assert_called_with(sp_search)
def test_releases_sp_user_when_user_dies(self, lib_mock):
sp_user = spotify.ffi.cast('sp_user *', 42)
user = spotify.User(self.session, sp_user=sp_user)
user = None # noqa
tests.gc_collect()
lib_mock.sp_user_release.assert_called_with(sp_user)
def test_releases_sp_toplistbrowse_when_toplist_dies(self, lib_mock):
sp_toplistbrowse = spotify.ffi.new('int *')
toplist = spotify.Toplist(sp_toplistbrowse=sp_toplistbrowse)
toplist = None # noqa
tests.gc_collect()
lib_mock.sp_toplistbrowse_release.assert_called_with(sp_toplistbrowse)
def test_releases_sp_search_when_search_dies(self, lib_mock):
sp_search = spotify.ffi.cast('sp_search *', 42)
search = spotify.Search(self.session, sp_search=sp_search)
search = None # noqa
tests.gc_collect()
lib_mock.sp_search_release.assert_called_with(sp_search)
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_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_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_releases_sp_inbox_when_result_dies(self, lib_mock):
sp_inbox = spotify.ffi.new('int *')
inbox_post_result = spotify.InboxPostResult(sp_inbox=sp_inbox)
inbox_post_result = None # noqa
tests.gc_collect()
lib_mock.sp_inbox_release.assert_called_with(sp_inbox)
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_releases_sp_track_when_track_dies(self, lib_mock):
sp_track = spotify.ffi.cast('sp_track *', 42)
track = spotify.Track(self.session, sp_track=sp_track)
track = None # noqa
tests.gc_collect()
lib_mock.sp_track_release.assert_called_with(sp_track)
def test_releases_sp_user_when_user_dies(self, lib_mock):
sp_user = spotify.ffi.new('int *')
user = spotify.User(sp_user=sp_user)
user = None # noqa
tests.gc_collect()
lib_mock.sp_user_release.assert_called_with(sp_user)
def test_releases_sp_image_when_image_dies(self, lib_mock):
sp_image = spotify.ffi.new('int *')
image = spotify.Image(sp_image=sp_image)
image = None # noqa
tests.gc_collect()
lib_mock.sp_image_release.assert_called_with(sp_image)
def test_releases_sp_artistbrowse_when_artist_dies(self, lib_mock):
sp_artistbrowse = spotify.ffi.new('int *')
browser = spotify.ArtistBrowser(sp_artistbrowse=sp_artistbrowse)
browser = None # noqa
tests.gc_collect()
lib_mock.sp_artistbrowse_release.assert_called_with(sp_artistbrowse)
def test_releases_sp_track_when_track_dies(self, lib_mock):
sp_track = spotify.ffi.new('int *')
track = spotify.Track(sp_track=sp_track)
track = None # noqa
tests.gc_collect()
lib_mock.sp_track_release.assert_called_with(sp_track)
def test_releases_sp_inbox_when_result_dies(self, lib_mock):
sp_inbox = spotify.ffi.cast('sp_inbox *', 42)
inbox_post_result = spotify.InboxPostResult(self.session,
sp_inbox=sp_inbox)
inbox_post_result = None # noqa
tests.gc_collect()
lib_mock.sp_inbox_release.assert_called_with(sp_inbox)
def test_releases_sp_albumbrowse_when_album_dies(self, lib_mock):
sp_albumbrowse = spotify.ffi.cast('sp_albumbrowse *', 42)
browser = spotify.AlbumBrowser(self.session,
sp_albumbrowse=sp_albumbrowse)
browser = None # noqa
tests.gc_collect()
lib_mock.sp_albumbrowse_release.assert_called_with(sp_albumbrowse)
def test_releases_sp_link_when_link_dies(self, lib_mock):
sp_link = spotify.ffi.cast('sp_link *', 42)
lib_mock.sp_link_create_from_string.return_value = sp_link
link = spotify.Link(self.session, 'spotify:track:foo')
link = None # noqa
tests.gc_collect()
lib_mock.sp_link_release.assert_called_with(sp_link)
def test_releases_sp_toplistbrowse_when_toplist_dies(self, lib_mock):
sp_toplistbrowse = spotify.ffi.cast('sp_toplistbrowse *', 42)
toplist = spotify.Toplist(self.session,
sp_toplistbrowse=sp_toplistbrowse)
toplist = None # noqa
tests.gc_collect()
lib_mock.sp_toplistbrowse_release.assert_called_with(sp_toplistbrowse)
def test_releases_sp_image_when_image_dies(self, lib_mock):
lib_mock.sp_image_add_load_callback.return_value = int(
spotify.ErrorType.OK)
sp_image = spotify.ffi.cast('sp_image *', 42)
image = spotify.Image(self.session, sp_image=sp_image)
image = None # noqa
tests.gc_collect()
lib_mock.sp_image_release.assert_called_with(sp_image)
def test_releases_sp_obj_when_sequence_dies(self, lib_mock):
sp_search = spotify.ffi.new('int *')
seq = utils.Sequence(sp_obj=sp_search,
add_ref_func=lib_mock.sp_search_add_ref,
release_func=lib_mock.sp_search_release,
len_func=None,
getitem_func=None)
seq = None # noqa
tests.gc_collect()
self.assertEqual(lib_mock.sp_search_release.call_count, 1)
def test_life_cycle(self, lib_mock):
sp_playlist = spotify.ffi.cast('sp_playlist *', 42)
playlist = spotify.Playlist(self.session, sp_playlist=sp_playlist)
sp_playlist = playlist._sp_playlist
lib_mock.sp_playlist_add_ref.assert_called_with(sp_playlist)
lib_mock.sp_playlist_add_callbacks.assert_called_with(
sp_playlist, mock.ANY, mock.ANY)
playlist = None # noqa
tests.gc_collect()
lib_mock.sp_playlist_remove_callbacks.assert_called_with(
sp_playlist, mock.ANY, mock.ANY)
def test_subscribers(self, lib_mock):
sp_subscribers = spotify.ffi.new('sp_subscribers *')
sp_subscribers.count = 1
user_alice = spotify.ffi.new('char[]', b'alice')
sp_subscribers.subscribers = [user_alice]
lib_mock.sp_playlist_subscribers.return_value = sp_subscribers
sp_playlist = spotify.ffi.cast('sp_playlist *', 42)
playlist = spotify.Playlist(self.session, sp_playlist=sp_playlist)
result = playlist.subscribers
lib_mock.sp_playlist_subscribers.assert_called_with(sp_playlist)
tests.gc_collect()
lib_mock.sp_playlist_subscribers_free.assert_called_with(sp_subscribers)
self.assertEqual(result, ['alice'])
def test_releases_sp_session_when_session_dies(self, lib_mock):
sp_session = spotify.ffi.NULL
def func(sp_session_config, sp_session_ptr):
sp_session_ptr[0] = sp_session
return spotify.ErrorType.OK
lib_mock.sp_session_create.side_effect = func
config = spotify.Config()
config.application_key = b'\x01' * 321
session = spotify.Session(config=config)
session = None # noqa
spotify._session_instance = None
tests.gc_collect()
lib_mock.sp_session_release.assert_called_with(sp_session)
def test_search_where_result_is_gone_before_callback_is_called(
self, lib_mock):
sp_search = spotify.ffi.cast('sp_search *', 42)
lib_mock.sp_search_create.return_value = sp_search
callback = mock.Mock()
result = spotify.Search(self.session, query='alice', 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.
search_complete_cb = lib_mock.sp_search_create.call_args[0][11]
userdata = lib_mock.sp_search_create.call_args[0][12]
search_complete_cb(sp_search, userdata)
loaded_event.wait(3)
self.assertEqual(callback.call_count, 1)
self.assertEqual(callback.call_args[0][0]._sp_search, sp_search)
