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)