io.jsonwebtoken.security.SecurityException#com.linecorp.linesdk.LineApiResponse源码实例Demo

@OnClick(R.id.revoke_access_token_btn)
void revokeToken() {
    startApiAsyncTask("revokeAccessToken", () -> {
        LineApiResponse<LineAccessToken> currentAccessTokenResponse = lineApiClient.getCurrentAccessToken();
        if (!currentAccessTokenResponse.isSuccess()) {
            return currentAccessTokenResponse;
        }
        try {
            String accessToken = currentAccessTokenResponse.getResponseData().getTokenString();
            String response = internalOauthApiClient.revokeAccessToken(channelId, accessToken);
            return LineApiResponse.createAsSuccess(response);
        } catch (IOException e) {
            return LineApiResponse.createAsError(
                    LineApiResponseCode.SERVER_ERROR,
                    new LineApiError(e));
        }
    });
}
 

private void getFriends(View view, String pageRequestToken) {
    startApiAsyncTask("getFriends", () -> {
        LineApiResponse<GetFriendsResponse> response =
                lineApiClient.getFriends(FriendSortField.NAME, pageRequestToken);

        if (response != null && response.isSuccess() && response.getResponseData() != null) {
            GetFriendsResponse getFriendsResponse = response.getResponseData();
            receivers.addFriends(getFriendsResponse.getFriends());

            // get next page if exists
            // postpone 2 seconds to make sure the first response data is logged. ONLY FOR TESTING purpose
            String nextPageRequestToken = getFriendsResponse.getNextPageRequestToken();
            if (nextPageRequestToken != null) {
                view.postDelayed(
                        () -> getFriends(view, nextPageRequestToken),
                        2000
                );
            }
        }

        return response;
    });
}
 

@Test
public void testRevokeAccessToken() throws Exception {
    LineApiResponse<?> expectedResponse = LineApiResponse.createAsSuccess(new Object());
    doReturn(expectedResponse).when(httpClient).post(
            any(Uri.class),
            anyMapOf(String.class, String.class),
            anyMapOf(String.class, String.class),
            any(ResponseDataParser.class));

    LineApiResponse<?> actualResponse = target.revokeAccessToken(CHANNEL_ID, ACCESS_TOKEN);

    assertSame(expectedResponse, actualResponse);

    Map<String, String> expectedPostData = new HashMap<>(2);
    expectedPostData.put("access_token", ACCESS_TOKEN.getAccessToken());
    expectedPostData.put("client_id", CHANNEL_ID);

    verify(httpClient, times(1)).post(
            eq(Uri.parse(API_BASE_URL + "/oauth2/v2.1/revoke")),
            eq(Collections.<String, String>emptyMap()),
            eq(expectedPostData),
            any(ResponseDataParser.class));
}
 

@Test
public void testSendMessageToMultipleUsersUsingOtt() {
    final LineApiResponse<?> mockResponse = LineApiResponse.createAsSuccess("");
    givenPostWithJsonApiResponse(mockResponse);

    LineApiResponse<List<SendMessageResponse>> actualResult =
            target.sendMessageToMultipleUsers(
                    ACCESS_TOKEN,
                    Collections.emptyList(),
                    Collections.emptyList(),
                    true);

    assertThat(actualResult, sameInstance(mockResponse));

    // Gets ott by target user ids
    verifyApiCallPostWithJson("/" + BASE_PATH_MESSAGE_API + "/" + PATH_OTT_ISSUE);
    responseParserInstanceShouldBe(TalkApiClient.StringParser.class);

    // Send the message using ott
    verifyApiCallPostWithJson("/" + BASE_PATH_MESSAGE_API + "/" + PATH_OTT_SHARE);
    responseParserInstanceShouldBe(TalkApiClient.MultiSendResponseParser.class);
}
 

@Test
public void testRefreshTokenWithNoRefreshToken() {
    accessTokenCache.saveAccessToken(ACCESS_TOKEN);
    LineApiResponse<RefreshTokenResult> refreshTokenResponse =
            LineApiResponse.createAsSuccess(new RefreshTokenResult(
                    "newAccessToken", 999L, null, Collections.emptyList()));
    doReturn(refreshTokenResponse)
            .when(internalOauthApiClient)
            .refreshToken(anyString(), any(InternalAccessToken.class));

    LineApiResponse<LineAccessToken> actualResponse = target.refreshAccessToken();

    verify(internalOauthApiClient, times(1)).refreshToken(CHANNEL_ID, ACCESS_TOKEN);
    assertTrue(actualResponse.isSuccess());
    assertNotNull(actualResponse.getResponseData());
    assertEquals("newAccessToken", actualResponse.getResponseData().getTokenString());
    assertEquals(999L, actualResponse.getResponseData().getExpiresInMillis());
    assertTrue(actualResponse.getResponseData().getIssuedClientTimeMillis() > 0);
    InternalAccessToken newAccessToken =
            accessTokenCache.getAccessToken();
    assertNotNull(newAccessToken);
    assertEquals("newAccessToken", newAccessToken.getAccessToken());
    assertEquals(999L, newAccessToken.getExpiresInMillis());
    assertTrue(newAccessToken.getIssuedClientTimeMillis() > 0);
    assertEquals(ACCESS_TOKEN.getRefreshToken(), newAccessToken.getRefreshToken());
}
 

@Test
public void testGetFriendshipStatus() {
    doReturn(EXPECTED_RESULT).when(httpClient).get(
            any(Uri.class),
            anyMapOf(String.class, String.class),
            anyMapOf(String.class, String.class),
            any(ResponseDataParser.class));

    LineApiResponse<LineFriendshipStatus> actualResult = target.getFriendshipStatus(ACCESS_TOKEN);

    assertSame(EXPECTED_RESULT, actualResult);

    verify(httpClient, times(1)).get(
            eq(Uri.parse(API_BASE_URL + "/friendship/v1/status")),
            eq(Collections.singletonMap("Authorization", "Bearer " + ACCESS_TOKEN.getAccessToken())),
            eq(Collections.emptyMap()),
            responseParserCaptor.capture());

    assertTrue(responseParserCaptor.getValue() instanceof TalkApiClient.FriendshipStatusParser);
}
 

@Test
public void testGetFriends_shareMessageWithOtt() {
    doReturn(EXPECTED_RESULT).when(httpClient).get(
            any(Uri.class),
            anyMapOf(String.class, String.class),
            anyMapOf(String.class, String.class),
            any(ResponseDataParser.class));

    LineApiResponse<GetFriendsResponse> actualResult =
            target.getFriends(ACCESS_TOKEN, FriendSortField.NAME, "pageToken01", true);

    assertSame(EXPECTED_RESULT, actualResult);

    Map<String, String> expectedQueryParams = new HashMap<>();
    expectedQueryParams.put("sort", "name");
    expectedQueryParams.put("pageToken", "pageToken01");

    verify(httpClient, times(1)).get(
            eq(Uri.parse(API_BASE_URL + "/" + BASE_PATH_GRAPH_API + "/" + PATH_OTS_FRIENDS)),
            eq(Collections.singletonMap("Authorization", "Bearer " + ACCESS_TOKEN.getAccessToken())),
            eq(expectedQueryParams),
            responseParserCaptor.capture());

    assertTrue(responseParserCaptor.getValue() instanceof TalkApiClient.FriendsParser);
}
 

@Override
@NonNull
public LineApiResponse<LineAccessToken> getCurrentAccessToken() {
    InternalAccessToken internalAccessToken;
    try {
        internalAccessToken = accessTokenCache.getAccessToken();
    } catch (Exception exception) {
        return LineApiResponse.createAsError(
                LineApiResponseCode.INTERNAL_ERROR,
                new LineApiError("get access token fail:" + exception.getMessage())
        );
    }

    if (internalAccessToken == null) {
        return LineApiResponse.createAsError(
                LineApiResponseCode.INTERNAL_ERROR,
                new LineApiError("The cached access token does not exist."));
    }

    return LineApiResponse.createAsSuccess(new LineAccessToken(
            internalAccessToken.getAccessToken(),
            internalAccessToken.getExpiresInMillis(),
            internalAccessToken.getIssuedClientTimeMillis()));
}
 

@Test
public void testSendMessageToMultipleUsersUsingOtt_getOtt_failed() {
    final LineApiResponse<?> mockResponse = LineApiResponse.createAsError(
            LineApiResponseCode.NETWORK_ERROR, new LineApiError(""));
    givenPostWithJsonApiResponse(mockResponse);

    LineApiResponse<List<SendMessageResponse>> actualApiResponse =
            target.sendMessageToMultipleUsers(
                    ACCESS_TOKEN,
                    Collections.emptyList(),
                    Collections.emptyList(),
                    true);

    assertThat(actualApiResponse.getResponseCode(), sameInstance(mockResponse.getResponseCode()));
    assertThat(actualApiResponse.getErrorData(), sameInstance(mockResponse.getErrorData()));

    // Gets ott by target user ids
    verifyApiCallPostWithJson("/" + BASE_PATH_MESSAGE_API + "/" + PATH_OTT_ISSUE);
    responseParserInstanceShouldBe(TalkApiClient.StringParser.class);

    // Should not send message due to failure of getting ott
    verify(target, never()).sendMessageToMultipleUsersUsingOtt(any(), any(), any());
}
 

@Test
public void testGetGroups_shareMessageWithOtt() {
    doReturn(EXPECTED_RESULT).when(httpClient).get(
            any(Uri.class),
            anyMapOf(String.class, String.class),
            anyMapOf(String.class, String.class),
            any(ResponseDataParser.class));

    LineApiResponse<GetGroupsResponse> actualResult =
            target.getGroups(ACCESS_TOKEN, "pageToken01", true);

    assertSame(EXPECTED_RESULT, actualResult);

    Map<String, String> expectedQueryParams = new HashMap<>();
    expectedQueryParams.put("pageToken", "pageToken01");

    verify(httpClient, times(1)).get(
            eq(Uri.parse(API_BASE_URL + "/" + BASE_PATH_GRAPH_API + "/" + PATH_OTS_GROUPS)),
            eq(Collections.singletonMap("Authorization", "Bearer " + ACCESS_TOKEN.getAccessToken())),
            eq(expectedQueryParams),
            responseParserCaptor.capture());

    assertTrue(responseParserCaptor.getValue() instanceof TalkApiClient.GroupParser);
}
 

@NonNull
public LineApiResponse<IssueAccessTokenResult> issueAccessToken(
        @NonNull String channelId,
        @NonNull String requestToken,
        @NonNull PKCECode pkceCode,
        @NonNull String redirectUri) {
    final Uri uri = buildUri(apiBaseUrl, BASE_PATH_OAUTH_V21_API, "token");
    final Map<String, String> postData = buildParams(
            "grant_type", "authorization_code",
            "code", requestToken,
            "redirect_uri", redirectUri,
            "client_id", channelId,
            "code_verifier", pkceCode.getVerifier(),
            "id_token_key_type", IdTokenKeyType.JWK.name(),
            "client_version", "LINE SDK Android v" + BuildConfig.VERSION_NAME
    );
    return httpClient.post(
            uri,
            emptyMap() /* requestHeaders */,
            postData,
            ISSUE_ACCESS_TOKEN_RESULT_PARSER);
}
 

@Test
public void testRefreshTokenWithApiError() {
    accessTokenCache.saveAccessToken(ACCESS_TOKEN);
    LineApiResponse<RefreshTokenResult> refreshTokenResponse =
            LineApiResponse.createAsError(
                    LineApiResponseCode.INTERNAL_ERROR, LineApiError.DEFAULT);
    doReturn(refreshTokenResponse)
            .when(internalOauthApiClient)
            .refreshToken(anyString(), any(InternalAccessToken.class));

    LineApiResponse<LineAccessToken> actualResponse = target.refreshAccessToken();

    verify(internalOauthApiClient, times(1)).refreshToken(CHANNEL_ID, ACCESS_TOKEN);
    assertFalse(actualResponse.isSuccess());
    assertEquals(ACCESS_TOKEN, accessTokenCache.getAccessToken());
}
 

@Test
public void testNetworkErrorOfGettingAccessToken() throws Exception {
    Intent newIntentData = new Intent();
    doReturn(BrowserAuthenticationApi.Result.createAsSuccess(REQUEST_TOKEN_STR, false))
            .when(browserAuthenticationApi)
            .getAuthenticationResultFrom(newIntentData);
    doReturn(LineApiResponse.createAsError(LineApiResponseCode.NETWORK_ERROR, LineApiError.DEFAULT))
            .when(authApiClient)
            .issueAccessToken(CHANNEL_ID, REQUEST_TOKEN_STR, PKCE_CODE, REDIRECT_URI);

    target.startLineAuthentication();

    Robolectric.getBackgroundThreadScheduler().runOneTask();
    Robolectric.getForegroundThreadScheduler().runOneTask();

    verify(browserAuthenticationApi, times(1))
            .getRequest(activity, config, PKCE_CODE, LINE_AUTH_PARAMS);

    target.handleIntentFromLineApp(newIntentData);

    Robolectric.getBackgroundThreadScheduler().runOneTask();
    Robolectric.getForegroundThreadScheduler().runOneTask();

    verify(activity, times(1)).onAuthenticationFinished(
            LineLoginResult.error(LineApiResponseCode.NETWORK_ERROR, LineApiError.DEFAULT));
}
 

@Test
public void testGetGroups_notShareMessageWithOtt() {
    doReturn(EXPECTED_RESULT).when(httpClient).get(
            any(Uri.class),
            anyMapOf(String.class, String.class),
            anyMapOf(String.class, String.class),
            any(ResponseDataParser.class));

    LineApiResponse<GetGroupsResponse> actualResult =
            target.getGroups(ACCESS_TOKEN, "pageToken01", false);

    assertSame(EXPECTED_RESULT, actualResult);

    Map<String, String> expectedQueryParams = new HashMap<>();
    expectedQueryParams.put("pageToken", "pageToken01");

    verify(httpClient, times(1)).get(
            eq(Uri.parse(API_BASE_URL + "/graph/v2/groups")),
            eq(Collections.singletonMap("Authorization", "Bearer " + ACCESS_TOKEN.getAccessToken())),
            eq(expectedQueryParams),
            responseParserCaptor.capture());

    assertTrue(responseParserCaptor.getValue() instanceof TalkApiClient.GroupParser);
}
 

@NonNull
public LineApiResponse<GetGroupsResponse> getGroups(
        @NonNull InternalAccessToken accessToken,
        @Nullable String pageToken,
        boolean isForOttShareMessage) {
    final String pathSegment = (isForOttShareMessage) ? PATH_OTS_GROUPS : PATH_GROUPS;
    final Uri uri = buildUri(apiBaseUrl, BASE_PATH_GRAPH_API, pathSegment);
    final Map<String, String> queryParams;
    if (!TextUtils.isEmpty(pageToken)) {
        queryParams = buildParams("pageToken", pageToken);
    } else {
        queryParams = Collections.emptyMap();
    }
    return httpClient.get(
            uri,
            buildRequestHeaders(accessToken),
            queryParams,
            GROUP_PARSER);
}
 

@Test
public void testAccessTokenExpiredByPostWithJson() throws Exception {
    setErrorData(HttpURLConnection.HTTP_UNAUTHORIZED, "testErrorMessage".getBytes(CHARSET));

    LineApiResponse<String> responseData = target.postWithJson(
            Uri.parse("https://test"),
            Collections.<String, String>emptyMap() /* requestHeaders */,
            ""  /* postData */,
            new StringResponseParser());

    assertFalse(responseData.isSuccess());
    assertEquals(LineApiResponseCode.SERVER_ERROR, responseData.getResponseCode());
    assertEquals(401, responseData.getErrorData().getHttpResponseCode());
    assertEquals("testErrorMessage", responseData.getErrorData().getMessage());
}
 

@Test
public void testPost() throws Exception {
    Map<String, String> requestHeaders = new HashMap();
    requestHeaders.put("headerKey1", "headerValue1");
    requestHeaders.put("headerKey2", "headerValue2");
    RequestParameter requestParameter = new RequestParameter()
            .put("param1", "value1")
            .put("param2", "value2&=");
    String postData = "param1=value1&param2=value2%26%3D";
    setResponseData("test".getBytes(CHARSET));

    LineApiResponse<String> responseData = target.post(
            Uri.parse("https://test"),
            requestHeaders,
            requestParameter.getMapData(),
            new StringResponseParser());

    verify(target).openHttpConnection(Uri.parse("https://test"));
    verify(httpsURLConnection).setRequestMethod("POST");
    verify(httpsURLConnection).setDoOutput(true);
    verify(httpsURLConnection).setRequestProperty("User-Agent", USER_AGENT);
    verify(httpsURLConnection).setRequestProperty("Accept-Encoding", "gzip");
    verify(httpsURLConnection).setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
    verify(httpsURLConnection).setRequestProperty("Content-Length", String.valueOf(postData.getBytes(CHARSET).length));
    verify(httpsURLConnection).setRequestProperty("headerKey1", "headerValue1");
    verify(httpsURLConnection).setRequestProperty("headerKey2", "headerValue2");
    verify(httpsURLConnection).setConnectTimeout(CONNECT_TIMEOUT_MILLIS);
    verify(httpsURLConnection).setReadTimeout(READ_TIMEOUT_MILLIS);

    assertEquals(postData, connectionOutputStream.toString(CHARSET));

    assertTrue(responseData.isSuccess());
    assertEquals("test", responseData.getResponseData());
    assertEquals(LineApiError.DEFAULT, responseData.getErrorData());
}
 

private void getAllGroups() {
    String nextPageToken = "";
    while (nextPageToken != null) {
        LineApiResponse<GetGroupsResponse> response =
                lineApiClient.getGroups(nextPageToken, true);
        if (!response.isSuccess()) {
            publishProgress(Collections.emptyList());
            return;
        }

        GetGroupsResponse getGroupsResponse = response.getResponseData();
        publishProgress(convertGroupsToTargetUsers(getGroupsResponse.getGroups()));
        nextPageToken = getGroupsResponse.getNextPageRequestToken();
    }
}
 

@Override
protected LineApiResponse<List<SendMessageResponse>> doInBackground(List<TargetUser>... targetUsers) {
    List<String> targetUserIds = new ArrayList<>();
    for (TargetUser targetUser : targetUsers[0]) {
        targetUserIds.add(targetUser.getId());
    }
    return lineApiClient.sendMessageToMultipleUsers(targetUserIds, messages, true);
}
 

@Override
protected void onPostExecute(LineApiResponse<List<SendMessageResponse>> lineApiResponse) {
    if (apiStatusListener != null) {
        if (lineApiResponse.isSuccess()) {
            apiStatusListener.onSuccess();
        } else {
            apiStatusListener.onFailure();
        }
    }
}
 

@NonNull
public LineApiResponse<MembershipStatus> getOpenChatMembershipStatus(
        @NonNull InternalAccessToken accessToken,
        @NonNull String roomId) {
    final Uri uri = buildUri(apiBaseUrl, BASE_PATH_OPENCHAT_API, "openchats", roomId, "members/me/membership");

    return httpClient.get(
            uri,
            buildRequestHeaders(accessToken),
            Collections.emptyMap(),
            OPEN_CHAT_MEMBERSHIP_PARSER);
}
 

@NonNull
public LineApiResponse<Boolean> getOpenChatAgreementStatus(
        @NonNull InternalAccessToken accessToken) {
    final Uri uri = buildUri(apiBaseUrl, BASE_PATH_OPENCHAT_API, "terms/agreement");

    return httpClient.get(
            uri,
            buildRequestHeaders(accessToken),
            Collections.emptyMap(),
            OPEN_CHAT_AGREEMENT_STATUS_PARSER);
}
 

@Test
public void testGetProfileWithApiCallError() {
    LineApiResponse<LineProfile> expectedResponse = LineApiResponse.createAsError(
            LineApiResponseCode.INTERNAL_ERROR, LineApiError.DEFAULT);
    doReturn(expectedResponse)
            .when(internalTalkApiClient)
            .getProfile(any(InternalAccessToken.class));
    accessTokenCache.saveAccessToken(ACCESS_TOKEN);

    LineApiResponse<LineProfile> actualResponse = target.getProfile();

    assertSame(expectedResponse, actualResponse);
    verify(internalTalkApiClient, times(1)).getProfile(ACCESS_TOKEN);
}
 

private void verifyAccessToken(CallbackContext callbackContext) {
    LineApiResponse verifyResponse = lineApiClient.verifyToken();
    if (verifyResponse.isSuccess()) {
        callbackContext.success();
    } else {
        this.SDKError(verifyResponse.getResponseCode().toString(), verifyResponse.getErrorData().toString());
    }
}
 

@Test
public void testRefreshErrorByNetworkError() throws Exception {
    when(lineApiClientImpl.getProfile()).thenReturn(
            Results.unauthorized());
    when(lineApiClientImpl.refreshAccessToken()).thenReturn(
            Results.networkError());

    LineApiResponse<LineProfile> response = target.getProfile();

    assertTrue(response.isNetworkError());
    verify(lineApiClientImpl, times(1)).refreshAccessToken();
    verify(lineApiClientImpl, times(1)).getProfile();
}
 

@Test
public void testLogoutWithApiCallError() {
    LineApiResponse<?> expectedResponse = LineApiResponse.createAsError(
            LineApiResponseCode.INTERNAL_ERROR, LineApiError.DEFAULT);
    doReturn(expectedResponse)
            .when(internalOauthApiClient)
            .revokeRefreshToken(anyString(), any(InternalAccessToken.class));
    accessTokenCache.saveAccessToken(ACCESS_TOKEN);

    LineApiResponse<?> actualResponse = target.logout();

    assertSame(expectedResponse, actualResponse);
    verify(internalOauthApiClient, times(1)).revokeRefreshToken(CHANNEL_ID, ACCESS_TOKEN);
    assertEquals(ACCESS_TOKEN, accessTokenCache.getAccessToken());
}
 

@Test
public void testNetworkErrorByDelete() throws Exception {
    IOException ioException = new IOException();
    doThrow(ioException).when(httpsURLConnection).connect();

    LineApiResponse<String> responseData = target.delete(
            Uri.parse("https://test"),
            Collections.<String, String>emptyMap() /* requestHeaders */,
            new StringResponseParser());

    assertFalse(responseData.isSuccess());
    assertEquals(LineApiResponseCode.NETWORK_ERROR, responseData.getResponseCode());
    assertEquals(new LineApiError(ioException), responseData.getErrorData());
}
 

@Test
public void testAccessTokenExpiredByDelete() throws Exception {
    setErrorData(HttpURLConnection.HTTP_UNAUTHORIZED, "testErrorMessage".getBytes(CHARSET));

    LineApiResponse<String> responseData = target.delete(
            Uri.parse("https://test"),
            Collections.<String, String>emptyMap() /* requestHeaders */,
            new StringResponseParser());

    assertFalse(responseData.isSuccess());
    assertEquals(LineApiResponseCode.SERVER_ERROR, responseData.getResponseCode());
    assertEquals(401, responseData.getErrorData().getHttpResponseCode());
    assertEquals("testErrorMessage", responseData.getErrorData().getMessage());
}
 

@NonNull
private LineApiResponse<LineCredential> verifyToken(@NonNull InternalAccessToken accessToken) {
    LineApiResponse<AccessTokenVerificationResult> response =
            oauthApiClient.verifyAccessToken(accessToken);
    if (!response.isSuccess()) {
        return LineApiResponse.createAsError(
                response.getResponseCode(), response.getErrorData());
    }
    AccessTokenVerificationResult verificationResult = response.getResponseData();
    long verifiedClientTimeMillis = System.currentTimeMillis();

    try {
        accessTokenCache.saveAccessToken(
                new InternalAccessToken(
                        accessToken.getAccessToken(),
                        verificationResult.getExpiresInMillis(),
                        verifiedClientTimeMillis,
                        accessToken.getRefreshToken()));
    } catch(Exception exception) {
        return LineApiResponse.createAsError(
                LineApiResponseCode.INTERNAL_ERROR,
                new LineApiError("save access token fail:" + exception.getMessage())
        );
    }

    return LineApiResponse.createAsSuccess(
            new LineCredential(
                    new LineAccessToken(
                            accessToken.getAccessToken(),
                            verificationResult.getExpiresInMillis(),
                            verifiedClientTimeMillis),
                    verificationResult.getScopes()));
}
 

@Override
@TokenAutoRefresh
@NonNull
public LineApiResponse<GetFriendsResponse> getFriends(
        @NonNull FriendSortField sort,
        @Nullable String nextPageRequestToken) {
    return getFriends(sort, nextPageRequestToken, false);
}