@Test public void shouldGetPlaylistsForCategory() throws Exception { final Type modelType = new TypeToken<PlaylistsPager>() {}.getType(); final String body = TestUtils.readTestData("category-playlist.json"); final PlaylistsPager fixture = mGson.fromJson(body, modelType); final Response response = TestUtils.getResponseFromModel(fixture, modelType); final String categoryId = "mood"; final String country = "SE"; final int offset = 1; final int limit = 2; when(mMockClient.execute( argThat( new ArgumentMatcher<Request>() { @Override public boolean matches(Object argument) { String requestUrl = ((Request) argument).getUrl(); return requestUrl.contains(String.format("limit=%d", limit)) && requestUrl.contains(String.format("offset=%d", offset)) && requestUrl.contains(String.format("country=%s", country)); } }))) .thenReturn(response); final Map<String, Object> options = new HashMap<String, Object>(); options.put("country", country); options.put("offset", offset); options.put("limit", limit); final PlaylistsPager result = mSpotifyService.getPlaylistsForCategory(categoryId, options); this.compareJSONWithoutNulls(body, result); }
@Test public void shouldFollowAPlaylist() throws Exception { final Type modelType = new TypeToken<Result>() {}.getType(); final String body = ""; // Returns empty body final Result fixture = mGson.fromJson(body, modelType); final Response response = TestUtils.getResponseFromModel(fixture, modelType); final String owner = "thelinmichael"; final String playlistId = "4JPlPnLULieb2WPFKlLiRq"; when(mMockClient.execute( argThat( new ArgumentMatcher<Request>() { @Override public boolean matches(Object argument) { final Request request = (Request) argument; return request .getUrl() .endsWith( String.format( "/users/%s/playlists/%s/followers", owner, playlistId)) && "PUT".equals(request.getMethod()); } }))) .thenReturn(response); final Result result = mSpotifyService.followPlaylist(owner, playlistId); this.compareJSONWithoutNulls(body, result); }
@Test public void shouldGetPlaylistFollowersContains() throws IOException { final Type modelType = new TypeToken<List<Boolean>>() {}.getType(); final String body = TestUtils.readTestData("playlist-followers-contains.json"); final List<Boolean> fixture = mGson.fromJson(body, modelType); final Response response = TestUtils.getResponseFromModel(fixture, modelType); final String userIds = "thelinmichael,jmperezperez,kaees"; when(mMockClient.execute( argThat( new ArgumentMatcher<Request>() { @Override public boolean matches(Object argument) { try { return ((Request) argument) .getUrl() .contains("ids=" + URLEncoder.encode(userIds, "UTF-8")); } catch (UnsupportedEncodingException e) { return false; } } }))) .thenReturn(response); final String requestPlaylist = TestUtils.readTestData("playlist-response.json"); final Playlist requestFixture = mGson.fromJson(requestPlaylist, Playlist.class); final Boolean[] result = mSpotifyService.areFollowingPlaylist(requestFixture.owner.id, requestFixture.id, userIds); this.compareJSONWithoutNulls(body, result); }
@Test public void shouldCheckFollowingArtists() throws IOException { Type modelType = new TypeToken<List<Boolean>>() {}.getType(); String body = TestUtils.readTestData("follow_is_following_artists.json"); List<Boolean> fixture = mGson.fromJson(body, modelType); final String artistIds = "3mOsjj1MhocRVwOejIZlTi"; Response response = TestUtils.getResponseFromModel(fixture, modelType); when(mMockClient.execute( argThat( new ArgumentMatcher<Request>() { @Override public boolean matches(Object argument) { try { return ((Request) argument).getUrl().contains("type=artist") && ((Request) argument) .getUrl() .contains("ids=" + URLEncoder.encode(artistIds, "UTF-8")); } catch (UnsupportedEncodingException e) { return false; } } }))) .thenReturn(response); Boolean[] result = mSpotifyService.isFollowingArtists(artistIds); this.compareJSONWithoutNulls(body, result); }
@Test public void shouldAddTracksToPlaylist() throws Exception { final Type modelType = new TypeToken<SnapshotId>() {}.getType(); final String body = TestUtils.readTestData("snapshot-response.json"); final SnapshotId fixture = mGson.fromJson(body, modelType); final Response response = TestUtils.getResponseFromModel(fixture, modelType); final String owner = "thelinmichael"; final String playlistId = "4JPlPnLULieb2WPFKlLiRq"; final String trackUri1 = "spotify:track:76lT30VRv09h5MQp5snmsb"; final String trackUri2 = "spotify:track:2KCmalBTv3SiYxvpKrXmr5"; final int position = 1; when(mMockClient.execute( argThat( new ArgumentMatcher<Request>() { @Override public boolean matches(Object argument) { final Request request = (Request) argument; final OutputStream outputStream = new ByteArrayOutputStream(); final TypedOutput output = request.getBody(); String body = null; try { output.writeTo(outputStream); body = outputStream.toString(); } catch (IOException e) { fail("Could not read body"); } final String expectedBody = String.format("{\"uris\":[\"%s\",\"%s\"]}", trackUri1, trackUri2); return request .getUrl() .endsWith( String.format( "/users/%s/playlists/%s/tracks?position=%d", owner, playlistId, position)) && JSONsContainSameData(expectedBody, body) && "POST".equals(request.getMethod()); } }))) .thenReturn(response); final Map<String, Object> options = new HashMap<String, Object>(); final List<String> trackUris = Arrays.asList(trackUri1, trackUri2); options.put("uris", trackUris); final Map<String, Object> queryParameters = new HashMap<String, Object>(); queryParameters.put("position", String.valueOf(position)); final SnapshotId result = mSpotifyService.addTracksToPlaylist(owner, playlistId, queryParameters, options); this.compareJSONWithoutNulls(body, result); }
@Test public void shouldRemoveTracksFromPlaylistSpecifyingPositions() throws Exception { final Type modelType = new TypeToken<SnapshotId>() {}.getType(); final String body = TestUtils.readTestData("snapshot-response.json"); final SnapshotId fixture = mGson.fromJson(body, modelType); final Response response = TestUtils.getResponseFromModel(fixture, modelType); final String owner = "thelinmichael"; final String playlistId = "4JPlPnLULieb2WPFKlLiRq"; final String trackUri1 = "spotify:track:76lT30VRv09h5MQp5snmsb"; final String trackUri2 = "spotify:track:2KCmalBTv3SiYxvpKrXmr5"; TracksToRemoveWithPosition ttrwp = new TracksToRemoveWithPosition(); TrackToRemoveWithPosition trackObject1 = new TrackToRemoveWithPosition(); trackObject1.uri = trackUri1; trackObject1.positions = Arrays.asList(0, 3); TrackToRemoveWithPosition trackObject2 = new TrackToRemoveWithPosition(); trackObject2.uri = trackUri2; trackObject2.positions = Arrays.asList(1); ttrwp.tracks = Arrays.asList(trackObject1, trackObject2); when(mMockClient.execute( argThat( new ArgumentMatcher<Request>() { @Override public boolean matches(Object argument) { final Request request = (Request) argument; final OutputStream outputStream = new ByteArrayOutputStream(); final TypedOutput output = request.getBody(); String body = null; try { output.writeTo(outputStream); body = outputStream.toString(); } catch (IOException e) { fail("Could not read body"); } final String expectedBody = String.format( "{\"tracks\":[{\"uri\":\"%s\",\"positions\":[0,3]},{\"uri\":\"%s\",\"positions\":[1]}]}", trackUri1, trackUri2); return request .getUrl() .endsWith( String.format("/users/%s/playlists/%s/tracks", owner, playlistId)) && JSONsContainSameData(expectedBody, body) && "DELETE".equals(request.getMethod()); } }))) .thenReturn(response); final SnapshotId result = mSpotifyService.removeTracksFromPlaylist(owner, playlistId, ttrwp); this.compareJSONWithoutNulls(body, result); }
@Test public void shouldGetSearchedPlaylists() throws IOException { String body = TestUtils.readTestData("search-playlist.json"); PlaylistsPager fixture = mGson.fromJson(body, PlaylistsPager.class); Response response = TestUtils.getResponseFromModel(fixture, PlaylistsPager.class); when(mMockClient.execute(isA(Request.class))).thenReturn(response); PlaylistsPager result = mSpotifyService.searchPlaylists("Christmas"); compareJSONWithoutNulls(body, result); }
@Test public void shouldGetArtistRelatedArtists() throws Exception { String body = TestUtils.readTestData("artist-related-artists.json"); Artists fixture = mGson.fromJson(body, Artists.class); Response response = TestUtils.getResponseFromModel(fixture, Artists.class); when(mMockClient.execute(isA(Request.class))).thenReturn(response); Artists tracks = mSpotifyService.getRelatedArtists("test"); compareJSONWithoutNulls(body, tracks); }
@Test public void shouldGetCurrentUserData() throws IOException { String body = TestUtils.readTestData("current-user.json"); User fixture = mGson.fromJson(body, User.class); Response response = TestUtils.getResponseFromModel(fixture, User.class); when(mMockClient.execute(Matchers.<Request>any())).thenReturn(response); User user = mSpotifyService.getMe(); this.compareJSONWithoutNulls(body, user); }
@Test public void shouldGetUserData() throws IOException { String body = TestUtils.readTestData("user.json"); UserSimple fixture = mGson.fromJson(body, UserSimple.class); Response response = TestUtils.getResponseFromModel(fixture, UserSimple.class); when(mMockClient.execute(argThat(new MatchesId(fixture.id)))).thenReturn(response); UserSimple userSimple = mSpotifyService.getUser(fixture.id); this.compareJSONWithoutNulls(body, userSimple); }
@Test public void shouldGetPlaylistData() throws IOException { String body = TestUtils.readTestData("playlist-response.json"); Playlist fixture = mGson.fromJson(body, Playlist.class); Response response = TestUtils.getResponseFromModel(fixture, Playlist.class); when(mMockClient.execute(isA(Request.class))).thenReturn(response); Playlist playlist = mSpotifyService.getPlaylist(fixture.owner.id, fixture.id); compareJSONWithoutNulls(body, playlist); }
@Test public void shouldGetAlbumData() throws IOException { String body = TestUtils.readTestData("album.json"); Album fixture = mGson.fromJson(body, Album.class); Response response = TestUtils.getResponseFromModel(fixture, Album.class); when(mMockClient.execute(argThat(new MatchesId(fixture.id)))).thenReturn(response); Album album = mSpotifyService.getAlbum(fixture.id); this.compareJSONWithoutNulls(body, album); }
@Test public void shouldReorderPlaylistsTracks() throws Exception { final Type modelType = new TypeToken<SnapshotId>() {}.getType(); final String body = TestUtils.readTestData("snapshot-response.json"); final SnapshotId fixture = mGson.fromJson(body, modelType); final Response response = TestUtils.getResponseFromModel(fixture, modelType); final String owner = "thelinmichael"; final String playlistId = "4JPlPnLULieb2WPFKlLiRq"; final int rangeStart = 2; final int rangeLength = 2; final int insertBefore = 0; when(mMockClient.execute( argThat( new ArgumentMatcher<Request>() { @Override public boolean matches(Object argument) { final Request request = (Request) argument; final OutputStream outputStream = new ByteArrayOutputStream(); final TypedOutput output = request.getBody(); String body = null; try { output.writeTo(outputStream); body = outputStream.toString(); } catch (IOException e) { fail("Could not read body"); } final String expectedBody = String.format( "{\"range_start\":%d,\"range_length\":%d,\"insert_before\":%d}", rangeStart, rangeLength, insertBefore); return request .getUrl() .endsWith( String.format("/users/%s/playlists/%s/tracks", owner, playlistId)) && JSONsContainSameData(expectedBody, body) && "PUT".equals(request.getMethod()); } }))) .thenReturn(response); final Map<String, Object> options = new HashMap<String, Object>(); options.put("range_start", rangeStart); options.put("range_length", rangeLength); options.put("insert_before", insertBefore); final SnapshotId result = mSpotifyService.reorderPlaylistTracks(owner, playlistId, options); this.compareJSONWithoutNulls(body, result); }
@Test public void shouldGetUserPlaylists() throws Exception { final Type modelType = new TypeToken<Pager<PlaylistSimple>>() {}.getType(); String body = TestUtils.readTestData("user-playlists.json"); Pager<PlaylistSimple> fixture = mGson.fromJson(body, modelType); Response response = TestUtils.getResponseFromModel(fixture, modelType); when(mMockClient.execute(isA(Request.class))).thenReturn(response); Pager<PlaylistSimple> playlists = mSpotifyService.getPlaylists("test"); compareJSONWithoutNulls(body, playlists); }
@Test public void shouldGetArtistsAlbumsData() throws IOException { Type modelType = new TypeToken<Pager<Album>>() {}.getType(); String artistId = "1vCWHaC5f2uS3yhpwWbIA6"; String body = TestUtils.readTestData("artist-album.json"); Pager<Album> fixture = mGson.fromJson(body, modelType); Response response = TestUtils.getResponseFromModel(fixture, modelType); when(mMockClient.execute(argThat(new MatchesId(artistId)))).thenReturn(response); Pager<Album> albums = mSpotifyService.getArtistAlbums(artistId); this.compareJSONWithoutNulls(body, albums); }
@Test public void shouldGetArtistTopTracksTracks() throws Exception { String body = TestUtils.readTestData("tracks-for-artist.json"); Tracks fixture = mGson.fromJson(body, Tracks.class); Response response = TestUtils.getResponseFromModel(fixture, Tracks.class); when(mMockClient.execute(isA(Request.class))).thenReturn(response); final Map<String, Object> options = new HashMap<String, Object>(); options.put(SpotifyService.OFFSET, 0); options.put(SpotifyService.LIMIT, 10); options.put(SpotifyService.COUNTRY, "SE"); Tracks tracks = mSpotifyService.getArtistTopTrack("test", options); compareJSONWithoutNulls(body, tracks); }
@Test public void shouldChangePlaylistDetails() throws Exception { final Type modelType = new TypeToken<Result>() {}.getType(); final String body = ""; // Returns empty body final Result fixture = mGson.fromJson(body, modelType); final Response response = TestUtils.getResponseFromModel(fixture, modelType); final String owner = "thelinmichael"; final String playlistId = "4JPlPnLULieb2WPFKlLiRq"; final String name = "Changed name"; final boolean isPublic = false; when(mMockClient.execute( argThat( new ArgumentMatcher<Request>() { @Override public boolean matches(Object argument) { final Request request = (Request) argument; final OutputStream outputStream = new ByteArrayOutputStream(); final TypedOutput output = request.getBody(); String body = null; try { output.writeTo(outputStream); body = outputStream.toString(); } catch (IOException e) { fail("Could not read body"); } final String expectedBody = String.format("{\"name\":\"%s\",\"public\":%b}", name, isPublic); return request .getUrl() .endsWith(String.format("/users/%s/playlists/%s", owner, playlistId)) && JSONsContainSameData(expectedBody, body) && "PUT".equals(request.getMethod()); } }))) .thenReturn(response); final Map<String, Object> options = new HashMap<String, Object>(); options.put("name", name); options.put("public", isPublic); final Result result = mSpotifyService.changePlaylistDetails(owner, playlistId, options); this.compareJSONWithoutNulls(body, result); }
public void displayOverlaySuggestion(String trackId) { mSpotifyService.getTrack( trackId, new Callback<SpotifyTrack>() { @Override public void success(SpotifyTrack spotifyTrack, Response response) { Log.d("akshay", "copied track fetch success: " + spotifyTrack); initOverlayView(spotifyTrack); showFragment(); } @Override public void failure(RetrofitError retrofitError) { Log.d("akshay", "error = " + retrofitError); } }); }
@Test public void shouldGetMultipleAlbumData() throws IOException { String body = TestUtils.readTestData("albums.json"); Albums fixture = mGson.fromJson(body, Albums.class); String ids = ""; for (int i = 0; i < fixture.albums.size(); i++) { if (i > 0) { ids += ","; } ids += fixture.albums.get(i).id; } Response response = TestUtils.getResponseFromModel(fixture, Albums.class); when(mMockClient.execute(argThat(new MatchesId(ids)))).thenReturn(response); Albums albums = mSpotifyService.getAlbums(ids); this.compareJSONWithoutNulls(body, albums); }
@Test public void shouldGetFeaturedPlaylists() throws IOException { final String countryId = "SE"; final String locale = "sv_SE"; final int limit = 5; String body = TestUtils.readTestData("featured-playlists.json"); FeaturedPlaylists fixture = mGson.fromJson(body, FeaturedPlaylists.class); Response response = TestUtils.getResponseFromModel(fixture, FeaturedPlaylists.class); when(mMockClient.execute( argThat( new ArgumentMatcher<Request>() { @Override public boolean matches(Object argument) { try { return ((Request) argument).getUrl().contains("limit=" + limit) && ((Request) argument) .getUrl() .contains("country=" + URLEncoder.encode(countryId, "UTF-8")) && ((Request) argument) .getUrl() .contains("locale=" + URLEncoder.encode(locale, "UTF-8")); } catch (UnsupportedEncodingException e) { return false; } } }))) .thenReturn(response); HashMap<String, Object> map = new HashMap<String, Object>(); map.put(SpotifyService.COUNTRY, countryId); map.put(SpotifyService.LOCALE, locale); map.put(SpotifyService.OFFSET, 0); map.put(SpotifyService.LIMIT, limit); FeaturedPlaylists featuredPlaylists = mSpotifyService.getFeaturedPlaylists(map); this.compareJSONWithoutNulls(body, featuredPlaylists); }
@Test public void shouldParseErrorResponse() throws Exception { final String body = TestUtils.readTestData("error-unauthorized.json"); final ErrorResponse fixture = mGson.fromJson(body, ErrorResponse.class); final Response response = TestUtils.getResponseFromModel(403, fixture, ErrorResponse.class); when(mMockClient.execute(isA(Request.class))).thenReturn(response); boolean errorReached = false; try { mSpotifyService.getMySavedTracks(); } catch (RetrofitError error) { errorReached = true; SpotifyError spotifyError = SpotifyError.fromRetrofitError(error); assertEquals(fixture.error.status, spotifyError.getErrorDetails().status); assertEquals(fixture.error.message, spotifyError.getErrorDetails().message); assertEquals(403, spotifyError.getRetrofitError().getResponse().getStatus()); } assertTrue(errorReached); }