tests.mock.ANY

Here are the examples of the python api tests.mock.ANY taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

24 Examples 7

Example 1

Project: pyspotify Source File: test_album.py
    def test_create_from_album(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

        result = album.browse()

        lib_mock.sp_albumbrowse_create.assert_called_with(
            self.session._sp_session, sp_album, mock.ANY, mock.ANY)
        self.assertIsInstance(result, spotify.AlbumBrowser)

        albumbrowse_complete_cb = (
            lib_mock.sp_albumbrowse_create.call_args[0][2])
        userdata = lib_mock.sp_albumbrowse_create.call_args[0][3]
        self.assertFalse(result.loaded_event.is_set())
        albumbrowse_complete_cb(sp_albumbrowse, userdata)
        self.assertTrue(result.loaded_event.is_set())

Example 2

Project: pyspotify Source File: test_artist.py
    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())

Example 3

Project: pyspotify Source File: test_link.py
    def test_create_from_uri(self, lib_mock):
        sp_link = spotify.ffi.cast('sp_link *', 42)
        lib_mock.sp_link_create_from_string.return_value = sp_link

        spotify.Link(self.session, 'spotify:track:foo')

        lib_mock.sp_link_create_from_string.assert_called_once_with(
            mock.ANY)
        self.assertEqual(
            spotify.ffi.string(
                lib_mock.sp_link_create_from_string.call_args[0][0]),
            b'spotify:track:foo')
        self.assertEqual(lib_mock.sp_link_add_ref.call_count, 0)

Example 4

Project: pyspotify Source File: test_link.py
    def test_create_from_open_spotify_com_url(self, lib_mock):
        sp_link = spotify.ffi.cast('sp_link *', 42)
        lib_mock.sp_link_create_from_string.return_value = sp_link

        spotify.Link(
            self.session,
            'http://open.spotify.com/track/bar ')

        lib_mock.sp_link_create_from_string.assert_called_once_with(
            mock.ANY)
        self.assertEqual(
            spotify.ffi.string(
                lib_mock.sp_link_create_from_string.call_args[0][0]),
            b'spotify:track:bar')

Example 5

Project: pyspotify Source File: test_link.py
    def test_create_from_play_spotify_com_url(self, lib_mock):
        sp_link = spotify.ffi.cast('sp_link *', 42)
        lib_mock.sp_link_create_from_string.return_value = sp_link

        spotify.Link(
            self.session,
            'https://play.spotify.com/track/bar?gurba=123')

        lib_mock.sp_link_create_from_string.assert_called_once_with(
            mock.ANY)
        self.assertEqual(
            spotify.ffi.string(
                lib_mock.sp_link_create_from_string.call_args[0][0]),
            b'spotify:track:bar')

Example 6

Project: pyspotify Source File: test_link.py
    def test_uri_grows_buffer_to_fit_link(self, lib_mock):
        sp_link = spotify.ffi.cast('sp_link *', 42)
        lib_mock.sp_link_create_from_string.return_value = sp_link
        string = 'foo' * 100

        lib_mock.sp_link_as_string.side_effect = tests.buffer_writer(string)
        link = spotify.Link(self.session, string)

        result = link.uri

        lib_mock.sp_link_as_string.assert_called_with(
            sp_link, mock.ANY, mock.ANY)
        self.assertEqual(result, string)

Example 7

Project: pyspotify Source File: test_offline.py
    def test_offline_sync_status(self, session_lib_mock, lib_mock):
        def func(sp_session_ptr, sp_offline_sync_status):
            sp_offline_sync_status.queued_tracks = 3
            return 1

        lib_mock.sp_offline_sync_get_status.side_effect = func
        session = tests.create_real_session(session_lib_mock)

        result = session.offline.sync_status

        lib_mock.sp_offline_sync_get_status.assert_called_with(
            session._sp_session, mock.ANY)
        self.assertIsInstance(result, spotify.OfflineSyncStatus)
        self.assertEqual(result.queued_tracks, 3)

Example 8

Project: pyspotify Source File: test_offline.py
    def test_offline_sync_status_when_not_syncing(
            self, session_lib_mock, lib_mock):
        lib_mock.sp_offline_sync_get_status.return_value = 0
        session = tests.create_real_session(session_lib_mock)

        result = session.offline.sync_status

        lib_mock.sp_offline_sync_get_status.assert_called_with(
            session._sp_session, mock.ANY)
        self.assertIsNone(result)

Example 9

Project: pyspotify Source File: test_session.py
    def test_login_with_password(self, lib_mock):
        lib_mock.sp_session_login.return_value = spotify.ErrorType.OK
        session = tests.create_real_session(lib_mock)

        session.login('alice', 'secret')

        lib_mock.sp_session_login.assert_called_once_with(
            session._sp_session, mock.ANY, mock.ANY,
            False, spotify.ffi.NULL)
        self.assertEqual(
            spotify.ffi.string(lib_mock.sp_session_login.call_args[0][1]),
            b'alice')
        self.assertEqual(
            spotify.ffi.string(lib_mock.sp_session_login.call_args[0][2]),
            b'secret')

Example 10

Project: pyspotify Source File: test_session.py
    def test_login_with_blob(self, lib_mock):
        lib_mock.sp_session_login.return_value = spotify.ErrorType.OK
        session = tests.create_real_session(lib_mock)

        session.login('alice', blob='secret blob')

        lib_mock.sp_session_login.assert_called_once_with(
            session._sp_session, mock.ANY, spotify.ffi.NULL,
            False, mock.ANY)
        self.assertEqual(
            spotify.ffi.string(lib_mock.sp_session_login.call_args[0][1]),
            b'alice')
        self.assertEqual(
            spotify.ffi.string(lib_mock.sp_session_login.call_args[0][4]),
            b'secret blob')

Example 11

Project: pyspotify Source File: test_session.py
    def test_login_with_remember_me_flag(self, lib_mock):
        lib_mock.sp_session_login.return_value = spotify.ErrorType.OK
        session = tests.create_real_session(lib_mock)

        session.login('alice', 'secret', remember_me='anything truish')

        lib_mock.sp_session_login.assert_called_once_with(
            session._sp_session, mock.ANY, mock.ANY,
            True, spotify.ffi.NULL)

Example 12

Project: pyspotify Source File: test_session.py
    def test_remembered_user_name_grows_buffer_to_fit_username(self, lib_mock):
        username = 'alice' * 100

        lib_mock.sp_session_remembered_user.side_effect = (
            tests.buffer_writer(username))
        session = tests.create_real_session(lib_mock)

        result = session.remembered_user_name

        lib_mock.sp_session_remembered_user.assert_called_with(
            session._sp_session, mock.ANY, mock.ANY)
        self.assertEqual(result, username)

Example 13

Project: pyspotify Source File: test_session.py
    def test_remembered_user_name_is_none_if_not_remembered(self, lib_mock):
        lib_mock.sp_session_remembered_user.return_value = -1
        session = tests.create_real_session(lib_mock)

        result = session.remembered_user_name

        lib_mock.sp_session_remembered_user.assert_called_with(
            session._sp_session, mock.ANY, mock.ANY)
        self.assertIsNone(result)

Example 14

Project: pyspotify Source File: test_sink.py
    def test_off_disconnects_from_music_delivery_event(self):
        self.assertEqual(self.session.off.call_count, 0)

        self.sink.off()

        self.session.off.assert_called_with(
            spotify.SessionEvent.MUSIC_DELIVERY, mock.ANY)

Example 15

Project: pyspotify Source File: test_social.py
    def test_is_scrobbling(self, session_lib_mock, lib_mock):

        def func(sp_session_ptr, sp_social_provider, sp_scrobbling_state_ptr):
            sp_scrobbling_state_ptr[0] = (
                spotify.ScrobblingState.USE_GLOBAL_SETTING)
            return spotify.ErrorType.OK

        lib_mock.sp_session_is_scrobbling.side_effect = func
        session = tests.create_real_session(session_lib_mock)

        result = session.social.is_scrobbling(spotify.SocialProvider.SPOTIFY)

        lib_mock.sp_session_is_scrobbling.assert_called_with(
            session._sp_session, spotify.SocialProvider.SPOTIFY, mock.ANY)
        self.assertIs(result, spotify.ScrobblingState.USE_GLOBAL_SETTING)

Example 16

Project: pyspotify Source File: test_social.py
    def test_is_scrobbling_possible(self, session_lib_mock, lib_mock):

        def func(sp_session_ptr, sp_social_provider, out_ptr):
            out_ptr[0] = 1
            return spotify.ErrorType.OK

        lib_mock.sp_session_is_scrobbling_possible.side_effect = func
        session = tests.create_real_session(session_lib_mock)

        result = session.social.is_scrobbling_possible(
            spotify.SocialProvider.FACEBOOK)

        lib_mock.sp_session_is_scrobbling_possible.assert_called_with(
            session._sp_session, spotify.SocialProvider.FACEBOOK, mock.ANY)
        self.assertTrue(result)

Example 17

Project: pyspotify Source File: test_social.py
    def test_set_social_credentials(self, session_lib_mock, lib_mock):
        lib_mock.sp_session_set_social_credentials.return_value = (
            spotify.ErrorType.OK)
        session = tests.create_real_session(session_lib_mock)

        session.social.set_social_credentials(
            spotify.SocialProvider.LASTFM, 'alice', 'secret')

        lib_mock.sp_session_set_social_credentials.assert_called_once_with(
            session._sp_session, spotify.SocialProvider.LASTFM,
            mock.ANY, mock.ANY)
        self.assertEqual(
            spotify.ffi.string(
                lib_mock.sp_session_set_social_credentials.call_args[0][2]),
            b'alice')
        self.assertEqual(
            spotify.ffi.string(
                lib_mock.sp_session_set_social_credentials.call_args[0][3]),
            b'secret')

Example 18

Project: pyspotify Source File: test_toplist.py
    def test_create_from_type_and_current_user_region(self, lib_mock):
        sp_toplistbrowse = spotify.ffi.cast('sp_toplistbrowse *', 42)
        lib_mock.sp_toplistbrowse_create.return_value = sp_toplistbrowse

        result = spotify.Toplist(
            self.session, type=spotify.ToplistType.TRACKS,
            region=spotify.ToplistRegion.USER)

        lib_mock.sp_toplistbrowse_create.assert_called_with(
            self.session._sp_session, int(spotify.ToplistType.TRACKS),
            int(spotify.ToplistRegion.USER), spotify.ffi.NULL,
            mock.ANY, mock.ANY)
        self.assertEqual(lib_mock.sp_toplistbrowse_add_ref.call_count, 0)
        self.assertEqual(result._sp_toplistbrowse, sp_toplistbrowse)

Example 19

Project: pyspotify Source File: test_toplist.py
    def test_create_from_type_and_specific_user_region(self, lib_mock):
        sp_toplistbrowse = spotify.ffi.cast('sp_toplistbrowse *', 42)
        lib_mock.sp_toplistbrowse_create.return_value = sp_toplistbrowse

        spotify.Toplist(
            self.session, type=spotify.ToplistType.TRACKS,
            region=spotify.ToplistRegion.USER, canonical_username='alice')

        lib_mock.sp_toplistbrowse_create.assert_called_with(
            self.session._sp_session, int(spotify.ToplistType.TRACKS),
            int(spotify.ToplistRegion.USER), mock.ANY, mock.ANY, mock.ANY)
        self.assertEqual(
            spotify.ffi.string(
                lib_mock.sp_toplistbrowse_create.call_args[0][3]),
            b'alice')

Example 20

Project: pyspotify Source File: test_toplist.py
    def test_create_from_type_and_country(self, lib_mock):
        sp_toplistbrowse = spotify.ffi.cast('sp_toplistbrowse *', 42)
        lib_mock.sp_toplistbrowse_create.return_value = sp_toplistbrowse

        spotify.Toplist(
            self.session, type=spotify.ToplistType.TRACKS, region='NO')

        lib_mock.sp_toplistbrowse_create.assert_called_with(
            self.session._sp_session, int(spotify.ToplistType.TRACKS),
            20047, spotify.ffi.NULL, mock.ANY, mock.ANY)

Example 21

Project: pyspotify Source File: test_track.py
    def test_set_starred(self, lib_mock):
        lib_mock.sp_track_set_starred.return_value = spotify.ErrorType.OK
        sp_track = spotify.ffi.cast('sp_track *', 42)
        track = spotify.Track(self.session, sp_track=sp_track)

        track.starred = True

        lib_mock.sp_track_set_starred.assert_called_with(
            self.session._sp_session, mock.ANY, 1, 1)

Example 22

Project: pyspotify Source File: test_image.py
    def test_data(self, lib_mock):
        lib_mock.sp_image_is_loaded.return_value = 1

        size = 20
        data = spotify.ffi.new('char[]', size)
        data[0:3] = [b'a', b'b', b'c']

        def func(sp_image_ptr, data_size_ptr):
            data_size_ptr[0] = size
            return spotify.ffi.cast('void *', data)

        lib_mock.sp_image_data.side_effect = func
        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)

        result = image.data

        lib_mock.sp_image_data.assert_called_with(sp_image, mock.ANY)
        self.assertEqual(result[:5], b'abc\x00\x00')

Example 23

Project: pyspotify Source File: test_search.py
Function: test_search
    def test_search(self, lib_mock):
        sp_search = spotify.ffi.cast('sp_search *', 42)
        lib_mock.sp_search_create.return_value = sp_search

        result = spotify.Search(self.session, query='alice')

        lib_mock.sp_search_create.assert_called_with(
            self.session._sp_session, mock.ANY,
            0, 20, 0, 20, 0, 20, 0, 20,
            int(spotify.SearchType.STANDARD), mock.ANY, mock.ANY)
        self.assertEqual(
            spotify.ffi.string(lib_mock.sp_search_create.call_args[0][1]),
            b'alice')
        self.assertEqual(lib_mock.sp_search_add_ref.call_count, 0)
        self.assertIsInstance(result, spotify.Search)

        self.assertFalse(result.loaded_event.is_set())
        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)
        self.assertTrue(result.loaded_event.wait(3))

Example 24

Project: pyspotify Source File: test_search.py
    def test_more(self, lib_mock):
        sp_search1 = spotify.ffi.cast('sp_search *', 42)
        sp_search2 = spotify.ffi.cast('sp_search *', 43)
        lib_mock.sp_search_create.side_effect = [sp_search1, sp_search2]
        lib_mock.sp_search_error.return_value = spotify.ErrorType.OK
        lib_mock.sp_search_query.return_value = spotify.ffi.new(
            'char[]', b'alice')

        result = spotify.Search(self.session, query='alice')

        lib_mock.sp_search_create.assert_called_with(
            self.session._sp_session, mock.ANY,
            0, 20, 0, 20, 0, 20, 0, 20,
            int(spotify.SearchType.STANDARD), mock.ANY, mock.ANY)
        self.assertEqual(
            spotify.ffi.string(lib_mock.sp_search_create.call_args[0][1]),
            b'alice')
        self.assertEqual(lib_mock.sp_search_add_ref.call_count, 0)
        self.assertIsInstance(result, spotify.Search)
        self.assertEqual(result._sp_search, sp_search1)

        result = result.more(
            track_count=30, album_count=30, artist_count=30, playlist_count=30)

        lib_mock.sp_search_create.assert_called_with(
            self.session._sp_session, mock.ANY,
            20, 30, 20, 30, 20, 30, 20, 30,
            int(spotify.SearchType.STANDARD), mock.ANY, mock.ANY)
        self.assertEqual(
            spotify.ffi.string(lib_mock.sp_search_create.call_args[0][1]),
            b'alice')
        self.assertEqual(lib_mock.sp_search_add_ref.call_count, 0)
        self.assertIsInstance(result, spotify.Search)
        self.assertEqual(result._sp_search, sp_search2)