def test_create_from_uri(self, link_mock, lib_mock):
sp_user = spotify.ffi.new('int *')
link_instance_mock = link_mock.return_value
link_instance_mock.as_user.return_value = spotify.User(sp_user=sp_user)
uri = 'spotify:user:foo'
result = spotify.User(uri)
link_mock.assert_called_with(uri)
link_instance_mock.as_user.assert_called_with()
lib_mock.sp_user_add_ref.assert_called_with(sp_user)
self.assertEqual(result._sp_user, sp_user)
def test_load(self, load_mock, lib_mock):
sp_user = spotify.ffi.new('int *')
user = spotify.User(sp_user=sp_user)
user.load(10)
load_mock.assert_called_with(user, timeout=10)
def test_load(self, load_mock, lib_mock):
sp_user = spotify.ffi.cast('sp_user *', 42)
user = spotify.User(self.session, sp_user=sp_user)
user.load(10)
load_mock.assert_called_with(self.session, user, timeout=10)
def test_create_from_uri_fail_raises_error(self, link_mock, lib_mock):
link_instance_mock = link_mock.return_value
link_instance_mock.as_user.return_value = None
uri = 'spotify:user:foo'
with self.assertRaises(ValueError):
spotify.User(self.session, uri=uri)
def creator(self):
"""The :class:`~spotify.User` that added the track to the playlist."""
return spotify.User(
self._session,
sp_user=lib.sp_playlist_track_creator(
self._sp_playlist, self._index),
add_ref=True)
def owner(self):
"""The :class:`User` object for the owner of the playlist container."""
return spotify.User(
self._session,
sp_user=lib.sp_playlistcontainer_owner(self._sp_playlistcontainer),
add_ref=True,
)
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_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_repr(self, link_mock, lib_mock):
link_instance_mock = link_mock.return_value
link_instance_mock.uri = 'foo'
sp_user = spotify.ffi.new('int *')
user = spotify.User(sp_user=sp_user)
result = repr(user)
self.assertEqual(result, 'User(%r)' % 'foo')
def test_is_loaded(self, lib_mock):
lib_mock.sp_user_is_loaded.return_value = 1
sp_user = spotify.ffi.new('int *')
user = spotify.User(sp_user=sp_user)
result = user.is_loaded
lib_mock.sp_user_is_loaded.assert_called_once_with(sp_user)
self.assertTrue(result)
def test_is_loaded(self, lib_mock):
lib_mock.sp_user_is_loaded.return_value = 1
sp_user = spotify.ffi.cast('sp_user *', 42)
user = spotify.User(self.session, sp_user=sp_user)
result = user.is_loaded
lib_mock.sp_user_is_loaded.assert_called_once_with(sp_user)
self.assertTrue(result)
def track_created_changed(sp_playlist, index, sp_user, when, userdata):
logger.debug('Playlist track created changed')
playlist = Playlist._cached(
spotify._session_instance, sp_playlist, add_ref=True)
user = spotify.User(
spotify._session_instance, sp_user=sp_user, add_ref=True)
playlist.emit(
PlaylistEvent.TRACK_CREATED_CHANGED,
playlist, int(index), user, int(when))
def test_repr(self, link_mock, lib_mock):
link_instance_mock = link_mock.return_value
link_instance_mock.uri = 'foo'
sp_user = spotify.ffi.cast('sp_user *', 42)
user = spotify.User(self.session, sp_user=sp_user)
result = repr(user)
self.assertEqual(result, 'User(%r)' % 'foo')
def test_display_name(self, lib_mock):
lib_mock.sp_user_display_name.return_value = spotify.ffi.new(
'char[]', b'Alice Foobar')
sp_user = spotify.ffi.cast('sp_user *', 42)
user = spotify.User(self.session, sp_user=sp_user)
result = user.display_name
lib_mock.sp_user_display_name.assert_called_once_with(sp_user)
self.assertEqual(result, 'Alice Foobar')
def test_canonical_name(self, lib_mock):
lib_mock.sp_user_canonical_name.return_value = spotify.ffi.new(
'char[]', b'alicefoobar')
sp_user = spotify.ffi.new('int *')
user = spotify.User(sp_user=sp_user)
result = user.canonical_name
lib_mock.sp_user_canonical_name.assert_called_once_with(sp_user)
self.assertEqual(result, 'alicefoobar')
def test_published_playlists_if_no_session(self, lib_mock):
spotify.session_instance = None
lib_mock.sp_user_canonical_name.return_value = spotify.ffi.new(
'char[]', b'alice')
sp_user = spotify.ffi.new('int *')
user = spotify.User(sp_user=sp_user)
result = user.published_playlists
self.assertIsNone(result)
def test_starred(self, lib_mock):
self.session.get_starred.return_value = mock.sentinel.playlist
lib_mock.sp_user_canonical_name.return_value = spotify.ffi.new(
'char[]', b'alice')
sp_user = spotify.ffi.cast('sp_user *', 42)
user = spotify.User(self.session, sp_user=sp_user)
result = user.starred
self.session.get_starred.assert_called_with('alice')
self.assertEqual(result, mock.sentinel.playlist)
def test_link_creates_link_to_user(self, link_mock, lib_mock):
sp_user = spotify.ffi.new('int *')
user = spotify.User(sp_user=sp_user)
sp_link = spotify.ffi.new('int *')
lib_mock.sp_link_create_from_user.return_value = sp_link
link_mock.return_value = mock.sentinel.link
result = user.link
link_mock.assert_called_once_with(sp_link=sp_link, add_ref=False)
self.assertEqual(result, mock.sentinel.link)
def test_starred(self, session_mock, lib_mock):
session_mock.starred_for_user.return_value = mock.sentinel.playlist
lib_mock.sp_user_canonical_name.return_value = spotify.ffi.new(
'char[]', b'alice')
sp_user = spotify.ffi.new('int *')
user = spotify.User(sp_user=sp_user)
result = user.starred
session_mock.starred_for_user.assert_called_with('alice')
self.assertEqual(result, mock.sentinel.playlist)
def test_published_playlists(self, lib_mock):
self.session.get_published_playlists.return_value = (
mock.sentinel.playlist_container)
lib_mock.sp_user_canonical_name.return_value = spotify.ffi.new(
'char[]', b'alice')
sp_user = spotify.ffi.cast('sp_user *', 42)
user = spotify.User(self.session, sp_user=sp_user)
result = user.published_playlists
self.session.get_published_playlists.assert_called_with('alice')
self.assertEqual(result, mock.sentinel.playlist_container)
def test_published_playlists(self, session_mock, lib_mock):
session_mock.published_playlists_for_user.return_value = (
mock.sentinel.playlist_container)
lib_mock.sp_user_canonical_name.return_value = spotify.ffi.new(
'char[]', b'alice')
sp_user = spotify.ffi.new('int *')
user = spotify.User(sp_user=sp_user)
result = user.published_playlists
session_mock.published_playlists_for_user.assert_called_with('alice')
self.assertEqual(result, mock.sentinel.playlist_container)
def get_user(self, uri):
"""
Get :class:`User` from a Spotify user URI.
Example::
>>> session = spotify.Session()
# ...
>>> user = session.get_user('spotify:user:jodal')
>>> user.load().display_name
u'jodal'
"""
return spotify.User(self, uri=uri)
async def add_tracks(self, playlist, spotify_uris):
"""
Params:
playlist : spotify.Playlist, or str of Playlist URI.
spotify_uris ([str]).
Returns:
(spotify.Playlist): the same one given as param.
"""
http_cli = HTTPUserClient(self.client_id, self.secret_key, self.bearer_token, None)
data = await http_cli.current_user()
try:
async with Client(self.client_id, self.secret_key) as spotify_client:
user = spotify.User(spotify_client, data, http=http_cli)
await user.add_tracks(playlist, *[uri for uri in spotify_uris])
except SpotifyException as e:
print("Could not add tracks to playlist with error:", e)
raise e
finally:
await http_cli.close()
return playlist
async def create_empty_playlist(self, name):
"""
Params:
name (str): name for new playlist.
Returns:
(spotify.Playlist).
"""
if self.bearer_token is None:
raise ValueError("Cannot create playlist without Bearer Token.")
http_cli = HTTPUserClient(self.client_id, self.secret_key, self.bearer_token, None)
data = await http_cli.current_user()
try:
async with Client(self.client_id, self.secret_key) as spotify_client:
user = spotify.User(spotify_client, data, http=http_cli)
return await user.create_playlist(name)
except SpotifyException as e:
print("Could not add tracks to playlist with error:", e)
raise e
finally:
await http_cli.close()
"""
This example should work, but fails to get the URIs of the playlists.
See related comment in :meth:`spotify.Link.__init__`.
"""
from __future__ import print_function
import time
import spotify
session = spotify.Session()
session.relogin()
session.process_events()
user = spotify.User('spotify:user:p3.no')
user.load()
user.published_playlists.load()
time.sleep(10)
session.process_events()
print('%d playlists found' % len(user.published_playlists))
for playlist in user.published_playlists:
playlist.load()
print('Loaded', playlist)
print(user.published_playlists)
session.logout()
def user(self):
"""The logged in :class:`User`."""
sp_user = lib.sp_session_user(self._sp_session)
if sp_user == ffi.NULL:
return None
return spotify.User(self, sp_user=sp_user, add_ref=True)
def test_adds_ref_to_sp_user_when_created(self, lib_mock):
sp_user = spotify.ffi.new('int *')
spotify.User(sp_user=sp_user)
lib_mock.sp_user_add_ref.assert_called_once_with(sp_user)
def as_user(self):
"""Make an :class:`User` from the link."""
sp_user = lib.sp_link_as_user(self._sp_link)
if sp_user == ffi.NULL:
return None
return spotify.User(self._session, sp_user=sp_user, add_ref=True)
def test_create_without_uri_or_sp_user_fails(self, lib_mock):
with self.assertRaises(AssertionError):
spotify.User(self.session)
def test_adds_ref_to_sp_user_when_created(self, lib_mock):
sp_user = spotify.ffi.cast('sp_user *', 42)
spotify.User(self.session, sp_user=sp_user)
lib_mock.sp_user_add_ref.assert_called_once_with(sp_user)
