From 6639a98e24b87cf0f9d470050cc3d00ecd2fbb91 Mon Sep 17 00:00:00 2001 From: Sandeep Murthy Date: Sat, 17 Feb 2018 17:33:01 +0000 Subject: [PATCH] Further clean up of tests --- requirements.txt | 1 + tests/authtests.py | 179 +++++++++++++++++------------- tests/authtests2.py | 63 +++++++---- tests/client_credentials_tests.py | 14 ++- tests/tests.py | 27 ++++- 5 files changed, 181 insertions(+), 103 deletions(-) diff --git a/requirements.txt b/requirements.txt index 708dccd..d674b24 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,4 @@ mock==2.0.0 requests==2.3.0 +simplejson==3.13.2 six==1.10.0 \ No newline at end of file diff --git a/tests/authtests.py b/tests/authtests.py index 13504a6..bd8f77c 100644 --- a/tests/authtests.py +++ b/tests/authtests.py @@ -1,24 +1,47 @@ -# -*- coding: latin-1 -*- +# -*- coding: utf-8 -*- -import spotipy -from spotipy import util -import unittest +""" +These tests require user authentication - provide client credentials using the +following environment variables + +:: + + 'SPOTIPY_CLIENT_USERNAME' + 'SPOTIPY_CLIENT_ID' + 'SPOTIPY_CLIENT_SECRET' + 'SPOTIPY_REDIRECT_URI' +""" + +from __future__ import print_function + +import os import pprint import sys +import unittest + import simplejson as json -''' - Since these tests require authentication they are maintained - separately from the other tests. +sys.path.insert(0, os.path.abspath(os.pardir)) + +from spotipy import ( + prompt_for_user_token, + Spotify, + SpotifyException, +) - These tests try to be benign and leave your collection and - playlists in a relatively stable state. -''' class AuthTestSpotipy(unittest.TestCase): - ''' - These tests require user authentication - ''' + """ + These tests require user authentication - provide client credentials using the + following environment variables + + :: + + 'SPOTIPY_CLIENT_USERNAME' + 'SPOTIPY_CLIENT_ID' + 'SPOTIPY_CLIENT_SECRET' + 'SPOTIPY_REDIRECT_URI' + """ playlist = "spotify:user:plamere:playlist:2oCEWyyAPbZp9xhVSxZavx" four_tracks = ["spotify:track:6RtPijgfPKROxEzTHNRiDp", @@ -35,38 +58,60 @@ class AuthTestSpotipy(unittest.TestCase): bad_id = 'BAD_ID' + @classmethod + def setUpClass(self): + client_cred_env_vars = ['SPOTIPY_CLIENT_USERNAME', 'SPOTIPY_CLIENT_ID', 'SPOTIPY_CLIENT_SECRET', 'SPOTIPY_REDIRECT_URI'] + missing = filter(lambda var: not os.getenv(var), client_cred_env_vars) + + if missing: + raise Exception('Please set the client credetials for the test application using the following environment variables: {}'.format(client_cred_env_vars)) + + self.username = os.getenv('SPOTIPY_CLIENT_USERNAME') + + self.scope = ( + 'playlist-modify-public ' + 'user-library-read ' + 'user-follow-read ' + 'user-library-modify ' + 'user-read-private ' + 'user-top-read' + ) + + self.token = prompt_for_user_token(self.username, scope=self.scope) + + self.spotify = Spotify(auth=self.token) + def test_track_bad_id(self): try: - track = spotify.track(self.bad_id) + track = self.spotify.track(self.bad_id) self.assertTrue(False) - except spotipy.SpotifyException: + except SpotifyException: self.assertTrue(True) - def test_basic_user_profile(self): - user = spotify.user(username) - self.assertTrue(user['id'] == username) + user = self.spotify.user(self.username) + self.assertTrue(user['id'] == self.username.lower()) def test_current_user(self): - user = spotify.current_user() - self.assertTrue(user['id'] == username) + user = self.spotify.current_user() + self.assertTrue(user['id'] == self.username.lower()) def test_me(self): - user = spotify.me() - self.assertTrue(user['id'] == username) + user = self.spotify.me() + self.assertTrue(user['id'] == self.username.lower()) def test_user_playlists(self): - playlists = spotify.user_playlists(username, limit=5) + playlists = self.spotify.user_playlists(self.username, limit=5) self.assertTrue('items' in playlists) self.assertTrue(len(playlists['items']) == 5) def test_user_playlist_tracks(self): - playlists = spotify.user_playlists(username, limit=5) + playlists = self.spotify.user_playlists(self.username, limit=5) self.assertTrue('items' in playlists) for playlist in playlists['items']: user = playlist['owner']['id'] pid = playlist['id'] - results = spotify.user_playlist_tracks(user, pid) + results = self.spotify.user_playlist_tracks(user, pid) self.assertTrue(len(results['items']) >= 0) def user_playlist_tracks(self, user, playlist_id = None, fields=None, @@ -79,144 +124,128 @@ class AuthTestSpotipy(unittest.TestCase): self.assertTrue(len(playlists['items']) == 5) def test_current_user_saved_tracks(self): - tracks = spotify.current_user_saved_tracks() + tracks = self.spotify.current_user_saved_tracks() self.assertTrue(len(tracks['items']) > 0) def test_current_user_saved_albums(self): - albums = spotify.current_user_saved_albums() + albums = self.spotify.current_user_saved_albums() self.assertTrue(len(albums['items']) > 0) def test_current_user_playlists(self): - playlists = spotify.current_user_playlists(limit=10) + playlists = self.spotify.current_user_playlists(limit=10) self.assertTrue('items' in playlists) self.assertTrue(len(playlists['items']) == 10) def test_user_playlist_follow(self): - spotify.user_playlist_follow_playlist('plamere', '4erXB04MxwRAVqcUEpu30O') - follows = spotify.user_playlist_is_following('plamere', '4erXB04MxwRAVqcUEpu30O', ['plamere']) + self.spotify.user_playlist_follow_playlist('plamere', '4erXB04MxwRAVqcUEpu30O') + follows = self.spotify.user_playlist_is_following('plamere', '4erXB04MxwRAVqcUEpu30O', [self.spotify.current_user()['id']]) self.assertTrue(len(follows) == 1, 'proper follows length') self.assertTrue(follows[0], 'is following') - spotify.user_playlist_unfollow('plamere', '4erXB04MxwRAVqcUEpu30O') + self.spotify.user_playlist_unfollow('plamere', '4erXB04MxwRAVqcUEpu30O') - follows = spotify.user_playlist_is_following('plamere', '4erXB04MxwRAVqcUEpu30O', ['plamere']) + follows = self.spotify.user_playlist_is_following('plamere', '4erXB04MxwRAVqcUEpu30O', [self.spotify.current_user()['id']]) self.assertTrue(len(follows) == 1, 'proper follows length') self.assertFalse(follows[0], 'is no longer following') def test_current_user_save_and_unsave_tracks(self): - tracks = spotify.current_user_saved_tracks() + tracks = self.spotify.current_user_saved_tracks() total = tracks['total'] - spotify.current_user_saved_tracks_add(self.four_tracks) + self.spotify.current_user_saved_tracks_add(self.four_tracks) - tracks = spotify.current_user_saved_tracks() + tracks = self.spotify.current_user_saved_tracks() new_total = tracks['total'] self.assertTrue(new_total - total == len(self.four_tracks)) - tracks = spotify.current_user_saved_tracks_delete(self.four_tracks) - tracks = spotify.current_user_saved_tracks() + tracks = self.spotify.current_user_saved_tracks_delete(self.four_tracks) + tracks = self.spotify.current_user_saved_tracks() new_total = tracks['total'] self.assertTrue(new_total == total) def test_categories(self): - response = spotify.categories() + response = self.spotify.categories() self.assertTrue(len(response['categories']) > 0) def test_category_playlists(self): - response = spotify.categories() + response = self.spotify.categories() for cat in response['categories']['items']: cat_id = cat['id'] - response = spotify.category_playlists(category_id=cat_id) + response = self.spotify.category_playlists(category_id=cat_id) self.assertTrue(len(response['playlists']["items"]) > 0) def test_new_releases(self): - response = spotify.new_releases() + response = self.spotify.new_releases() self.assertTrue(len(response['albums']) > 0) def test_featured_releases(self): - response = spotify.featured_playlists() + response = self.spotify.featured_playlists() self.assertTrue(len(response['playlists']) > 0) def test_current_user_follows(self): - response = spotify.current_user_followed_artists() + response = self.spotify.current_user_followed_artists() artists = response['artists'] self.assertTrue(len(artists['items']) > 0) def test_current_user_top_tracks(self): - response = spotify.current_user_top_tracks() + response = self.spotify.current_user_top_tracks() items = response['items'] self.assertTrue(len(items) > 0) def test_current_user_top_artists(self): - response = spotify.current_user_top_artists() + response = self.spotify.current_user_top_artists() items = response['items'] self.assertTrue(len(items) > 0) - def get_or_create_spotify_playlist(self, username, playlist_name): - playlists = spotify.user_playlists(username) + def get_or_create_spotify_playlist(self, playlist_name): + playlists = self.spotify.user_playlists(self.username) while playlists: for item in playlists['items']: if item['name'] == playlist_name: return item['id'] - playlists = spotify.next(playlists) - playlist = spotify.user_playlist_create(username, playlist_name) + playlists = self.spotify.next(playlists) + playlist = self.spotify.user_playlist_create(self.username, playlist_name) playlist_id = playlist['uri'] return playlist_id def test_user_playlist_ops(self): # create empty playlist - playlist_id = self.get_or_create_spotify_playlist(username, - 'spotipy-testing-playlist-1') + playlist_id = self.get_or_create_spotify_playlist('spotipy-testing-playlist-1') # remove all tracks from it - spotify.user_playlist_replace_tracks(username, playlist_id,[]) + self.spotify.user_playlist_replace_tracks(self.username, playlist_id,[]) - playlist = spotify.user_playlist(username, playlist_id) + playlist = self.spotify.user_playlist(self.username, playlist_id) self.assertTrue(playlist['tracks']['total'] == 0) self.assertTrue(len(playlist['tracks']['items']) == 0) # add tracks to it - spotify.user_playlist_add_tracks(username, playlist_id, self.four_tracks) - playlist = spotify.user_playlist(username, playlist_id) + self.spotify.user_playlist_add_tracks(self.username, playlist_id, self.four_tracks) + playlist = self.spotify.user_playlist(self.username, playlist_id) self.assertTrue(playlist['tracks']['total'] == 4) self.assertTrue(len(playlist['tracks']['items']) == 4) # remove two tracks from it - spotify.user_playlist_remove_all_occurrences_of_tracks (username, + self.spotify.user_playlist_remove_all_occurrences_of_tracks (self.username, playlist_id, self.two_tracks) - playlist = spotify.user_playlist(username, playlist_id) + playlist = self.spotify.user_playlist(self.username, playlist_id) self.assertTrue(playlist['tracks']['total'] == 2) self.assertTrue(len(playlist['tracks']['items']) == 2) # replace with 3 other tracks - spotify.user_playlist_replace_tracks(username, + self.spotify.user_playlist_replace_tracks(self.username, playlist_id, self.other_tracks) - playlist = spotify.user_playlist(username, playlist_id) + playlist = self.spotify.user_playlist(self.username, playlist_id) self.assertTrue(playlist['tracks']['total'] == 3) self.assertTrue(len(playlist['tracks']['items']) == 3) if __name__ == '__main__': - if len(sys.argv) > 1: - username = sys.argv[1] - del sys.argv[1] - scope = 'playlist-modify-public ' - scope += 'user-library-read ' - scope += 'user-follow-read ' - scope += 'user-library-modify ' - scope += 'user-read-private ' - scope += 'user-top-read' - - token = util.prompt_for_user_token(username, scope) - spotify = spotipy.Spotify(auth=token) - spotify.trace = False - unittest.main() - else: - print("Usage: %s username" % (sys.argv[0],)) + unittest.main() diff --git a/tests/authtests2.py b/tests/authtests2.py index 670e1c8..d68667d 100644 --- a/tests/authtests2.py +++ b/tests/authtests2.py @@ -1,25 +1,44 @@ -# -*- coding: latin-1 -*- +# -*- coding: utf-8 -*- -import spotipy -from spotipy import util -import unittest +""" +These tests require user authentication - provide client credentials using the +following environment variables + +:: + + 'SPOTIPY_CLIENT_USERNAME' + 'SPOTIPY_CLIENT_ID' + 'SPOTIPY_CLIENT_SECRET' + 'SPOTIPY_REDIRECT_URI' +""" + +import os import pprint import sys +import unittest + import simplejson as json -from spotipy.oauth2 import SpotifyClientCredentials -''' - Since these tests require authentication they are maintained - separately from the other tests. +sys.path.insert(0, os.path.abspath(os.pardir)) + +from spotipy import ( + Spotify, + SpotifyClientCredentials, +) - These tests try to be benign and leave your collection and - playlists in a relatively stable state. -''' class AuthTestSpotipy(unittest.TestCase): - ''' - These tests require user authentication - ''' + """ + These tests require user authentication - provide client credentials using the + following environment variables + + :: + + 'SPOTIPY_CLIENT_USERNAME' + 'SPOTIPY_CLIENT_ID' + 'SPOTIPY_CLIENT_SECRET' + 'SPOTIPY_REDIRECT_URI' + """ playlist = "spotify:user:plamere:playlist:2oCEWyyAPbZp9xhVSxZavx" four_tracks = ["spotify:track:6RtPijgfPKROxEzTHNRiDp", @@ -36,13 +55,17 @@ class AuthTestSpotipy(unittest.TestCase): bad_id = 'BAD_ID' + @classmethod + def setUpClass(self): + self.spotify = Spotify(client_credentials_manager=SpotifyClientCredentials()) + self.spotify.trace = False def test_audio_analysis(self): - result = spotify.audio_analysis(self.four_tracks[0]) + result = self.spotify.audio_analysis(self.four_tracks[0]) assert('beats' in result) def test_audio_features(self): - results = spotify.audio_features(self.four_tracks) + results = self.spotify.audio_features(self.four_tracks) self.assertTrue(len(results) == len(self.four_tracks)) for track in results: assert('speechiness' in track) @@ -51,7 +74,7 @@ class AuthTestSpotipy(unittest.TestCase): bad_tracks = [] bad_tracks = ['spotify:track:bad'] input = self.four_tracks + bad_tracks - results = spotify.audio_features(input) + results = self.spotify.audio_features(input) self.assertTrue(len(results) == len(input)) for track in results[:-1]: if track != None: @@ -59,12 +82,10 @@ class AuthTestSpotipy(unittest.TestCase): self.assertTrue(results[-1] == None) def test_recommendations(self): - results = spotify.recommendations(seed_tracks=self.four_tracks, min_danceability=0, max_loudness=0, target_popularity=50) + results = self.spotify.recommendations(seed_tracks=self.four_tracks, min_danceability=0, max_loudness=0, target_popularity=50) self.assertTrue(len(results['tracks']) == 20) if __name__ == '__main__': - client_credentials_manager = SpotifyClientCredentials() - spotify = spotipy.Spotify(client_credentials_manager=client_credentials_manager) - spotify.trace = False + unittest.main() diff --git a/tests/client_credentials_tests.py b/tests/client_credentials_tests.py index aaaab75..a3b7103 100644 --- a/tests/client_credentials_tests.py +++ b/tests/client_credentials_tests.py @@ -15,9 +15,17 @@ from spotipy import ( class ClientCredentialsTestSpotipy(unittest.TestCase): - ''' - These tests require user authentication - ''' + """ + These tests require user authentication - provide client credentials using the + following environment variables + + :: + + 'SPOTIPY_CLIENT_USERNAME' + 'SPOTIPY_CLIENT_ID' + 'SPOTIPY_CLIENT_SECRET' + 'SPOTIPY_REDIRECT_URI' + """ @classmethod def setUpClass(self): diff --git a/tests/tests.py b/tests/tests.py index cfdfb9e..babc375 100644 --- a/tests/tests.py +++ b/tests/tests.py @@ -18,6 +18,18 @@ from spotipy import ( class TestSpotipy(unittest.TestCase): + """ + These tests require user authentication - provide client credentials using the + following environment variables + + :: + + 'SPOTIPY_CLIENT_USERNAME' + 'SPOTIPY_CLIENT_ID' + 'SPOTIPY_CLIENT_SECRET' + 'SPOTIPY_REDIRECT_URI' + """ + creep_urn = 'spotify:track:3HfB5hBU0dmBt8T0iCmH42' creep_id = '3HfB5hBU0dmBt8T0iCmH42' creep_url = 'http://open.spotify.com/track/3HfB5hBU0dmBt8T0iCmH42' @@ -34,13 +46,20 @@ class TestSpotipy(unittest.TestCase): @classmethod def setUpClass(self): - self.token = os.getenv('SPOTIPY_CLIENT_TOKEN') - if not self.token: - raise Exception('Set your Spotify client app token via the environment variable `SPOTIPY_CLIENT_TOKEN`') + client_cred_env_vars = ['SPOTIPY_CLIENT_USERNAME', 'SPOTIPY_CLIENT_ID', 'SPOTIPY_CLIENT_SECRET', 'SPOTIPY_REDIRECT_URI'] + missing = filter(lambda var: not os.getenv(var), client_cred_env_vars) + + if missing: + raise Exception('Please set the client credetials for the test application using the following environment variables: {}'.format(client_cred_env_vars)) + + self.username = os.getenv('SPOTIPY_CLIENT_USERNAME') + + self.scope = 'user-library-read' + + self.token = prompt_for_user_token(self.username, scope=self.scope) self.spotify = Spotify(auth=self.token) - def test_artist_urn(self): artist = self.spotify.artist(self.radiohead_urn) self.assertTrue(artist['name'] == 'Radiohead')