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])