@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 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 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 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 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 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);
  }
Esempio n. 15
0
  @Override
  public Response execute(Request request) throws IOException {
    Response response = wrappedClient.execute(request);

    boolean gzipped = false;
    for (Header h : response.getHeaders()) {
      if (h.getName() != null
          && h.getName().toLowerCase().equals("content-encoding")
          && h.getValue() != null
          && h.getValue().toLowerCase().equals("gzip")) {
        gzipped = true;
        break;
      }
    }

    Response r = null;
    if (gzipped) {
      InputStream is = null;
      ByteArrayOutputStream bos = null;

      try {
        is = new BufferedInputStream(new GZIPInputStream(response.getBody().in()));
        bos = new ByteArrayOutputStream();

        int b;
        while ((b = is.read()) != -1) {
          bos.write(b);
        }

        TypedByteArray body = new TypedByteArray(response.getBody().mimeType(), bos.toByteArray());
        r =
            new Response(
                response.getUrl(),
                response.getStatus(),
                response.getReason(),
                response.getHeaders(),
                body);
      } finally {
        if (is != null) {
          is.close();
        }
        if (bos != null) {
          bos.close();
        }
      }
    } else {
      r = response;
    }
    return r;
  }
  @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);
  }
  @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);
  }
  @Override
  public Response execute(Request request) throws IOException {
    try {
      if (!ConnectivityUtil.isConnected(context)) {
        throw RetrofitError.unexpectedError(
            "Nincs internet", new NoConnectivityException("No Internet"));
      } else {

        Response r = wrappedClient.execute(request);

        checkResult(r);

        return r;
      }
    } catch (RetrofitError retrofitError) {
      if (retry(retrofitError, retries)) {
        return execute(request);
      } else {
        throw new ConnectionError();
      }
    } catch (Exception e) {
      throw new ConnectionError();
    }
  }
  @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);
  }