def test_has_saved(self):
user = self.user
# Validate input checking
playlist = get_dummy_data(const.PLAYLISTS, 1)[0]
self.assertRaises(TypeError, user.has_saved, playlist)
self.assertRaises(TypeError, user.has_saved, 5)
# Build some objects to check
tracks = get_dummy_data(const.TRACKS)
tracks = [Track(None, data) for data in tracks]
albums = get_dummy_data(const.ALBUMS)
albums = [Album(None, data) for data in albums]
other = tracks + albums
random.shuffle(other)
# Return correct number of values depending on input
#pylint: disable=unused-argument
def request_mock_return(session,
request_type,
endpoint,
body,
uri_params):
ret_len = len(tracks) if 'tracks' in endpoint else len(albums)
return [True]*ret_len, 200
self.request_mock.side_effect = request_mock_return
self.assertTrue(all(user.has_saved(other)))
def test_remove(self):
user = self.user
albums = get_dummy_data(const.ALBUMS, 10, to_obj=True)
album_ids = utils.map_ids(albums)
tracks = get_dummy_data(const.TRACKS, 10, to_obj=True)
playlists = get_dummy_data(const.PLAYLISTS, 10, to_obj=True)
# Validate input checking
self.assertRaises(TypeError, user.remove, playlists)
# Make sure saving albums does what's expected
#pylint: disable=unused-argument
def request_mock_return(session,
request_type,
endpoint,
body,
uri_params):
self.assertEqual(request_type, const.REQUEST_DELETE)
self.assertIsNotNone(uri_params)
self.assertTrue('ids' in uri_params)
for elem in uri_params['ids']:
self.assertIsInstance(elem, str)
self.assertTrue(elem in album_ids)
return None, 200
self.request_mock.side_effect = request_mock_return
user.remove(albums)
# Should not raise exception - expects code 200 for playlists
self.request_mock.side_effect = [(None, 200)]*10
user.remove(tracks)
def test_update_fields(self):
self.request_mock.return_value = (
get_dummy_data(const.ARTISTS, limit=1)[0],
200
)
expected_artist = get_dummy_data(
const.ARTISTS,
limit=1,
to_obj=True
)[0]
artist = Artist(
session=self.session,
info={
'id': expected_artist.spotify_id()
}
)
# Check state before updating the fields
self.assertTrue(artist == expected_artist)
# pylint: disable=protected-access
self.assertEqual(artist._raw.__len__(), 1)
# Check state after updating the fields
artist._update_fields()
self.assertTrue(artist == expected_artist)
# pylint: disable=protected-access
self.assertEqual(artist._raw.__len__(), expected_artist._raw.__len__())
def test_dunder(self):
# Get 2 instances of the same album
album1 = get_dummy_data(const.ALBUMS, limit=1, to_obj=True)[0]
album1_dup = get_dummy_data(const.ALBUMS, limit=1, to_obj=True)[0]
# eq, hash
self.assertEqual(album1, album1_dup)
self.assertEqual(hash(album1), hash(album1_dup))
self.assertIsNot(album1, album1_dup)
# str, repr should return str and not raise exceptions
self.assertIsInstance(album1.__str__(), str)
self.assertIsInstance(album1.__repr__(), str)
# Get a second album to compare for ne
album2 = get_dummy_data(const.ALBUMS, limit=2, to_obj=True)[1]
self.assertNotEqual(album1, album2)
# The dummy_data albums don't have Tracks, so mock the Spotify request
# TODO: should this be fixed?
response_json = {
'items': get_dummy_data(const.TRACKS, limit=10),
'total': 10,
'limit': 50,
'offset': 0
}
empty_response = {'items': [], 'total': 0, 'limit': 50, 'offset': 50}
self.request_mock.side_effect = [(response_json, 200),
(empty_response, 200)]
# iter / next
counter = 0
for track in album1:
# contains
self.assertIn(track, album1)
# getitem
self.assertIs(album1[counter], track)
self.assertIsInstance(track, Track)
counter += 1
# len
self.assertEqual(len(album1), counter)
self.assertEqual(len(album1), 10)
# reversed
counter = len(album1) - 1
for track in reversed(album1):
self.assertIn(track, album1)
self.assertIs(album1[counter], track)
counter -= 1
def test_related_artists(self):
self.request_mock.return_value = (
{
'artists': get_dummy_data(const.ARTISTS, limit=20)
},
200
)
expected_artists = get_dummy_data(const.ARTISTS, limit=20, to_obj=True)
artist = get_dummy_data(const.ARTISTS, limit=1, to_obj=True)[0]
related_artists = artist.related_artists()
self.assertEqual(related_artists, expected_artists)
def test_top_tracks(self):
self.request_mock.return_value = (
{
'tracks': get_dummy_data(const.TRACKS, limit=10)
},
200
)
expected_tracks = get_dummy_data(const.TRACKS, limit=10, to_obj=True)
artist = get_dummy_data(const.ARTISTS, limit=1, to_obj=True)[0]
tracks = artist.top_tracks()
self.assertEqual(tracks, expected_tracks)
def test_albums_with_no_limit(self):
search_limit = 100
expected_albums_json = get_dummy_data(
const.ALBUMS,
limit=search_limit,
)
expected_albums = get_dummy_data(
const.ALBUMS,
limit=search_limit,
to_obj=True
)
self.request_mock.side_effect = [
(
{
'href': 'href_uri',
'items': expected_albums_json[:50],
'limit': 50,
'next': 'next_here',
'offset': 0,
'previous': 'previous_uri',
'total': 100,
},
200
),
(
{
'href': 'href_uri',
'items': expected_albums_json[50:100],
'limit': 50,
'next': 'next_here',
'offset': 50,
'previous': 'previous_uri',
'total': 100,
},
200
),
(
{
'href': 'href_uri',
'items': [],
'limit': 50,
'next': None,
'offset': 100,
'previous': 'previous_uri',
'total': 100,
},
200
)
]
artist = get_dummy_data(const.ARTISTS, limit=1, to_obj=True)[0]
albums = artist.albums()
self.assertEqual(albums, expected_albums)
def test_top(self):
user = self.user
# Validate input checking
self.assertRaises(TypeError, user.top, const.PLAYLISTS, 1)
self.assertRaises(TypeError, user.top, const.TRACKS, 1, const.ARTISTS)
self.assertRaises(TypeError, user.top, const.TRACKS, 1, 5)
self.assertRaises(ValueError, user.top, const.TRACKS, -1)
# Get top track
# Want to mock items, limit, offset
self.request_mock.return_value = (
{'items': get_dummy_data(const.TRACKS, 1),
'offset': 0,
'limit': 1},
200
)
top = user.top(const.TRACKS, 1)
self.assertLessEqual(len(top), 1)
for elem in top:
self.assertIsInstance(elem, Track)
# Get top artist
self.request_mock.return_value = (
{'items': get_dummy_data(const.ARTISTS, 1),
'offset': 0,
'limit': 1},
200
)
top = user.top(const.ARTISTS, 1)
self.assertLessEqual(len(top), 1)
for elem in top:
self.assertIsInstance(elem, Artist)
# Get at most 55 top tracks
top_tracks = get_dummy_data(const.TRACKS, 100)
self.request_mock.side_effect = [
({'items': top_tracks[:50],
'offset': 0,
'limit': 50},
200),
({'items': top_tracks[50:],
'offset': 50,
'limit': 50},
200)
]
top = user.top(const.TRACKS, 55)
self.assertLessEqual(len(top), 55)
def test_get_saved(self):
user = self.user
# Validate input checking
self.assertRaises(TypeError, user.get_saved, const.PLAYLISTS)
self.assertRaises(ValueError, user.get_saved, const.TRACKS, limit=-1)
# Test getting tracks
dummy_tracks = get_dummy_data(const.TRACKS, 101)
self.request_mock.side_effect = [
({'items': dummy_tracks[:50]}, 200),
({'items': dummy_tracks[50:100]}, 200),
({'items': dummy_tracks[100:]}, 200),
({'items': []}, 200)
]
tracks = user.get_saved(const.TRACKS)
self.assertEqual(101, len(tracks))
for elem in tracks:
self.assertIsInstance(elem, Track)
self.request_mock.side_effect = [
({'items': dummy_tracks[:50]}, 200),
({'items': dummy_tracks[51:100]}, 200),
({'items': dummy_tracks[100]}, 200),
({'items': []}, 200)
]
self.assertEqual(99, len(user.get_saved(const.TRACKS, limit=99)))
# Test getting tracks
dummy_albums = get_dummy_data(const.ALBUMS, 75)
self.request_mock.side_effect = [
({'items': dummy_albums[:50]}, 200),
({'items': dummy_albums[50:]}, 200),
({'items': []}, 200)
]
albums = user.get_saved(const.ALBUMS)
self.assertEqual(75, len(albums))
for elem in albums:
self.assertIsInstance(elem, Album)
self.request_mock.side_effect = [
({'items': dummy_albums[:50]}, 200),
({'items': dummy_albums[51:]}, 200),
({'items': []}, 200)
]
self.assertEqual(73, len(user.get_saved(const.ALBUMS, limit=73)))
def test_dunder(self):
# Get 2 instances of the same album
playlist1 = get_dummy_data(const.PLAYLISTS, limit=1, to_obj=True)[0]
playlist1_dup = get_dummy_data(const.PLAYLISTS, limit=1, to_obj=True)[0]
# eq, hash
self.assertEqual(playlist1, playlist1_dup)
self.assertEqual(hash(playlist1), hash(playlist1_dup))
self.assertIsNot(playlist1, playlist1_dup)
# str, repr should return str and not raise exceptions
self.assertIsInstance(playlist1.__str__(), str)
self.assertIsInstance(playlist1.__repr__(), str)
# Get a second playlist to compare for ne
playlist2 = get_dummy_data(const.PLAYLISTS, limit=2, to_obj=True)[1]
self.assertNotEqual(playlist1, playlist2)
# insert tracks into playlist1
# pylint: disable=protected-access
playlist1._tracks = get_dummy_data(const.TRACKS, limit=10, to_obj=True)
# iter / next
counter = 0
for track in playlist1:
# contains
self.assertIn(track, playlist1)
# getitem
self.assertIs(playlist1[counter], track)
self.assertIsInstance(track, Track)
counter += 1
# len
self.assertEqual(len(playlist1), counter)
self.assertEqual(len(playlist1), 10)
# reversed
counter = len(playlist1) - 1
for track in reversed(playlist1):
self.assertIn(track, playlist1)
self.assertIs(playlist1[counter], track)
counter -= 1
def test_get_playlists(self):
user = self.user
self.assertRaises(ValueError, user.get_playlists, -1)
self.assertRaises(ValueError, user.get_playlists, 100001)
# Make sure you get 1 Playlist
self.request_mock.side_effect = [
({'items': get_dummy_data(const.PLAYLISTS, 1),
'offset': 0,
'limit': 50},
200),
({'items': []},
200),
]
playlist = user.get_playlists(1)
self.assertEqual(len(playlist), 1)
self.assertIsInstance(playlist[0], Playlist)
self.request_mock.side_effect = [
({'items': get_dummy_data(const.PLAYLISTS, 38),
'offset': 0,
'limit': 50},
200),
({'items': []},
200)
]
playlists = user.get_playlists()
self.assertEqual(len(playlists), 38)
self.request_mock.side_effect = [
({'items': get_dummy_data(const.PLAYLISTS, 37),
'offset': 0,
'limit': 50},
200),
({'items': []},
200)
]
playlists = user.get_playlists(37)
self.assertEqual(len(playlists), 37)
def test_is_following(self):
user = self.user
# Validate input checking
self.assertRaises(TypeError, user.is_following, const.TRACKS)
self.assertRaises(TypeError, user.is_following, 5)
self.request_mock.side_effect = [
({'items': get_dummy_data(const.PLAYLISTS, 10)}, 200),
([True]*10, 200)
]
# Note: current
playlists = user.get_following(const.PLAYLISTS)
self.assertEqual(len(playlists), 0)
self.request_mock.side_effect = [
({'items': get_dummy_data(const.ARTISTS, 10)}, 200),
([True]*10, 200)
]
artists = user.get_following(const.ARTISTS)
self.assertTrue(all(user.is_following(artists)))
def test_create_playlist(self):
user = self.user
# Validate input checking
self.assertRaises(TypeError, user.create_playlist, 'test', const.TRACKS)
to_make = get_dummy_data(const.PLAYLISTS, 1)[0]
self.request_mock.return_value = to_make, 201
# Make sure playlist creation returns the playlist
new_playlist = user.create_playlist(to_make['name'],
const.PRIVATE,
description=to_make['description'])
self.assertIsInstance(new_playlist, Playlist)
self.assertEqual(new_playlist.name(), to_make['name'])
def test_recently_played(self):
user = self.user
# Validate input checking
self.assertRaises(ValueError, user.recently_played, -1)
self.assertRaises(ValueError, user.recently_played, 51)
# Make sure you get at most 10 Tracks
self.request_mock.return_value = (
{'items': get_dummy_data(const.TRACKS, 10)},
200
)
recently_played = user.recently_played(10)
self.assertLessEqual(len(recently_played), 10)
for elem in recently_played:
self.assertIsInstance(elem, Track)
def test_field_accessors(self):
artists = get_dummy_data(const.ARTISTS, limit=2, to_obj=True)
artist_0, artist_1 = artists[0], artists[1]
self.assertTrue(all((isinstance(genre, str) for genre in x.genres()) \
for x in [artist_0, artist_1])
)
self.assertTrue(all(
isinstance(x.href(), str) for x in [artist_0, artist_1])
)
self.assertTrue(all(isinstance(x.spotify_id(), str) \
for x in [artist_0, artist_1]))
self.assertTrue(all(isinstance(x.name(), str) \
for x in [artist_0, artist_1]))
self.assertTrue(all(isinstance(x.popularity(), int) \
for x in [artist_0, artist_1]))
self.assertTrue(all(isinstance(x.uri(), str) \
for x in [artist_0, artist_1]))
from tests.help_lib import get_dummy_data
import spotifython.constants as const
import spotifython.utils as utils
USER_ID = 'deadbeef'
TOKEN = 'feebdaed'
TOKEN1 = TOKEN + TOKEN
SEARCH_LIMIT_ALBUMS = 100
SEARCH_LIMIT_ARTISTS = 100
SEARCH_LIMIT_PLAYLISTS = 23
SEARCH_LIMIT_TRACKS = 59
SEARCH_LIMIT_USERS = 5
expected_albums_json = get_dummy_data(
const.ALBUMS,
limit=SEARCH_LIMIT_ALBUMS,
)
expected_albums = get_dummy_data(const.ALBUMS,
limit=SEARCH_LIMIT_ALBUMS,
to_obj=True)
expected_artists_json = get_dummy_data(
const.ARTISTS,
limit=SEARCH_LIMIT_ARTISTS,
)
expected_artists = get_dummy_data(const.ARTISTS,
limit=SEARCH_LIMIT_ARTISTS,
to_obj=True)
expected_playlists_json = get_dummy_data(
const.PLAYLISTS,
def test_str_overloads(self):
artist = get_dummy_data(const.ARTISTS, limit=1, to_obj=True)[0]
self.assertTrue(isinstance(artist.__str__(), str))
self.assertTrue(isinstance(artist.__repr__(), str))
def test_equality_overloads(self):
artists = get_dummy_data(const.ARTISTS, limit=2, to_obj=True)
self.assertTrue(artists[0] != artists[1])
self.assertTrue(artists[0] == artists[0])
self.assertTrue(artists[1] == artists[1])