diff --git a/lib/src/main/java/com/ibm/bluemix/appid/android/api/userattributes/UserAttributeManager.java b/lib/src/main/java/com/ibm/bluemix/appid/android/api/userattributes/UserAttributeManager.java index 6f41cf1..777c8a2 100644 --- a/lib/src/main/java/com/ibm/bluemix/appid/android/api/userattributes/UserAttributeManager.java +++ b/lib/src/main/java/com/ibm/bluemix/appid/android/api/userattributes/UserAttributeManager.java @@ -19,14 +19,14 @@ public interface UserAttributeManager { void setAttribute(@NonNull String name, @NonNull String value, UserAttributeResponseListener listener); - void setAttribute(@NonNull String name, @NonNull String value, @NonNull AccessToken accessToken, UserAttributeResponseListener listener); + void setAttribute(@NonNull String name, @NonNull String value, AccessToken accessToken, UserAttributeResponseListener listener); void getAttribute(@NonNull String name, UserAttributeResponseListener listener); - void getAttribute(@NonNull String name, @NonNull AccessToken accessToken, UserAttributeResponseListener listener); + void getAttribute(@NonNull String name, AccessToken accessToken, UserAttributeResponseListener listener); void deleteAttribute(@NonNull String name, UserAttributeResponseListener listener); - void deleteAttribute(@NonNull String name, @NonNull AccessToken accessToken, UserAttributeResponseListener listener); + void deleteAttribute(@NonNull String name, AccessToken accessToken, UserAttributeResponseListener listener); void getAllAttributes(@NonNull UserAttributeResponseListener listener); - void getAllAttributes(@NonNull AccessToken accessToken, @NonNull UserAttributeResponseListener listener); + void getAllAttributes(AccessToken accessToken, @NonNull UserAttributeResponseListener listener); } diff --git a/lib/src/main/java/com/ibm/bluemix/appid/android/api/userattributes/UserAttributesException.java b/lib/src/main/java/com/ibm/bluemix/appid/android/api/userattributes/UserAttributesException.java index 0d36b34..7083a2d 100644 --- a/lib/src/main/java/com/ibm/bluemix/appid/android/api/userattributes/UserAttributesException.java +++ b/lib/src/main/java/com/ibm/bluemix/appid/android/api/userattributes/UserAttributesException.java @@ -30,6 +30,11 @@ public String getDescription(){ public String getDescription(){ return "Access to attribute is unauthorized"; } + }, + JSON_PARSE_ERROR { + public String getDescription(){ + return "Response text is not a valid JSON format"; + } }; public abstract String getDescription(); diff --git a/lib/src/main/java/com/ibm/bluemix/appid/android/internal/authorizationmanager/AuthorizationUIManager.java b/lib/src/main/java/com/ibm/bluemix/appid/android/internal/authorizationmanager/AuthorizationUIManager.java index 4eff6c8..db08061 100644 --- a/lib/src/main/java/com/ibm/bluemix/appid/android/internal/authorizationmanager/AuthorizationUIManager.java +++ b/lib/src/main/java/com/ibm/bluemix/appid/android/internal/authorizationmanager/AuthorizationUIManager.java @@ -46,9 +46,9 @@ class AuthorizationUIManager { private static final String DEV_PACKAGE = "com.chrome.dev"; private static final String LOCAL_PACKAGE = "com.google.android.apps.chrome"; private static final String ACTION_CUSTOM_TABS_CONNECTION = "android.support.customtabs.action.CustomTabsService"; - public static final String EXTRA_URL = "com.ibm.bluemix.appid.android.URL"; - public static final String EXTRA_AUTH_FLOW_CONTEXT_GUID = "com.ibm.bluemix.appid.android.AUTH_FLOW_CONTEXT_GUID"; - public static final String EXTRA_REDIRECT_URL = "com.ibm.bluemix.appid.android.REDIRECT_URL"; + static final String EXTRA_URL = "com.ibm.bluemix.appid.android.URL"; + static final String EXTRA_AUTH_FLOW_CONTEXT_GUID = "com.ibm.bluemix.appid.android.AUTH_FLOW_CONTEXT_GUID"; + static final String EXTRA_REDIRECT_URL = "com.ibm.bluemix.appid.android.REDIRECT_URL"; private static CustomTabsClient mClient; private static CustomTabsSession mCustomTabsSession; @@ -64,13 +64,18 @@ class AuthorizationUIManager { private static boolean isChromeTabSupported = true; // TODO: document - public AuthorizationUIManager(OAuthManager oAuthManager, AuthorizationListener authorizationListener, String serverUrl, String redirectUrl) { + AuthorizationUIManager(OAuthManager oAuthManager, AuthorizationListener authorizationListener, String serverUrl, String redirectUrl) { this.oAuthManager = oAuthManager; this.authorizationListener = authorizationListener; this.serverUrl = serverUrl; this.redirectUrl = redirectUrl; } + //for testing + Intent createChromeTabIntent(Activity activity) { + return new Intent(activity, ChromeTabActivity.class); + } + public void launch(final Activity activity) { final Context context = activity.getApplicationContext(); String authFlowContextGuid = UUID.randomUUID().toString(); @@ -86,12 +91,11 @@ public void launch(final Activity activity) { } else { // Use Chrome tabs logger.debug("Launching ChromeTabActivity"); - Intent intent = new Intent(activity, ChromeTabActivity.class); + Intent intent = createChromeTabIntent(activity); intent.putExtra(EXTRA_AUTH_FLOW_CONTEXT_GUID, authFlowContextGuid); intent.putExtra(EXTRA_REDIRECT_URL, redirectUrl); intent.putExtra(EXTRA_URL, serverUrl); // Open ChromeTabActivity that will open the ChromeTab on top of it - intent.putExtra(EXTRA_URL, serverUrl); activity.startActivity(intent); } } @@ -230,5 +234,10 @@ public void onNavigationEvent(int navigationEvent, Bundle extras) { return mCustomTabsSession; } + //for testing + void reset_sPackageNameToUse(){ + sPackageNameToUse = null; + } + } diff --git a/lib/src/main/java/com/ibm/bluemix/appid/android/internal/userattributesmanager/UserAttributeManagerImpl.java b/lib/src/main/java/com/ibm/bluemix/appid/android/internal/userattributesmanager/UserAttributeManagerImpl.java index fa9bede..7927084 100644 --- a/lib/src/main/java/com/ibm/bluemix/appid/android/internal/userattributesmanager/UserAttributeManagerImpl.java +++ b/lib/src/main/java/com/ibm/bluemix/appid/android/internal/userattributesmanager/UserAttributeManagerImpl.java @@ -45,16 +45,14 @@ public UserAttributeManagerImpl(TokenManager tokenManager){ @Override public void setAttribute (@NonNull String name, @NonNull String value, UserAttributeResponseListener listener) { - this.setAttribute(name, value, null, listener); } @Override - public void setAttribute (@NonNull String name, @NonNull String value, @NonNull AccessToken accessToken, final UserAttributeResponseListener listener) { - if(accessToken == null){ + public void setAttribute (@NonNull String name, @NonNull String value, AccessToken accessToken, final UserAttributeResponseListener listener) { + if(accessToken == null) { accessToken = tokenManager.getLatestAccessToken(); } - sendProtectedRequest(AppIDRequest.PUT, name, value, accessToken, listener); } @@ -64,7 +62,7 @@ public void getAttribute (@NonNull String name, UserAttributeResponseListener li } @Override - public void getAttribute (@NonNull String name, @NonNull AccessToken accessToken, UserAttributeResponseListener listener) { + public void getAttribute (@NonNull String name, AccessToken accessToken, UserAttributeResponseListener listener) { if(accessToken == null){ accessToken = tokenManager.getLatestAccessToken(); } @@ -77,7 +75,7 @@ public void deleteAttribute (@NonNull String name, UserAttributeResponseListener } @Override - public void deleteAttribute (@NonNull String name, @NonNull AccessToken accessToken, UserAttributeResponseListener listener) { + public void deleteAttribute (@NonNull String name, AccessToken accessToken, UserAttributeResponseListener listener) { if(accessToken == null){ accessToken = tokenManager.getLatestAccessToken(); } @@ -90,18 +88,27 @@ public void getAllAttributes(@NonNull UserAttributeResponseListener listener) { } @Override - public void getAllAttributes(@NonNull AccessToken accessToken, @NonNull UserAttributeResponseListener listener) { - if(accessToken == null){ + public void getAllAttributes(AccessToken accessToken, @NonNull UserAttributeResponseListener listener) { + if (accessToken == null) { accessToken = tokenManager.getLatestAccessToken(); } sendProtectedRequest(AppIDRequest.GET, null, null, accessToken, listener); } + //for testing purpose + AppIDRequest createAppIDRequest(String url, String method) { + return new AppIDRequest(url, method); + } + //for testing purpose + RequestBody createRequestBody(String value) { + return RequestBody.create(MediaType.parse("application/json"), value); + } + private void sendProtectedRequest(String method, String name, String value, AccessToken accessToken, final UserAttributeResponseListener listener){ String url = Config.getUserProfilesServerUrl(AppID.getInstance()) + USER_PROFILE_ATTRIBUTES_PATH; url = (name == null || name.length() == 0) ? url : url + '/' + name; - AppIDRequest req = new AppIDRequest(url, method); + AppIDRequest req = createAppIDRequest(url, method); ResponseListener resListener = new ResponseListener() { @Override @@ -111,6 +118,7 @@ public void onSuccess(Response response) { try { listener.onSuccess(new JSONObject(responseText)); } catch (JSONException e) { + listener.onFailure(new UserAttributesException(UserAttributesException.Error.JSON_PARSE_ERROR)); e.printStackTrace(); } } @@ -134,7 +142,7 @@ public void onFailure(Response response, Throwable t, JSONObject extendedInfo) { }; RequestBody requestBody = - (value == null || value.length() == 0) ? null : RequestBody.create(MediaType.parse("application/json"), value); + (value == null || value.length() == 0) ? null : createRequestBody(value); req.send (resListener, requestBody, accessToken); } diff --git a/lib/src/test/java/com/ibm/bluemix/appid/android/TestSuite.java b/lib/src/test/java/com/ibm/bluemix/appid/android/TestSuite.java index 8dd27a1..a0fcb54 100644 --- a/lib/src/test/java/com/ibm/bluemix/appid/android/TestSuite.java +++ b/lib/src/test/java/com/ibm/bluemix/appid/android/TestSuite.java @@ -22,11 +22,16 @@ import com.ibm.bluemix.appid.android.api.tokens.OAuthClient_Test; import com.ibm.bluemix.appid.android.api.userattributes.UserAttributesException_Test; import com.ibm.bluemix.appid.android.internal.authorizationmanager.AuthorizationManager_Test; +import com.ibm.bluemix.appid.android.internal.authorizationmanager.AuthorizationUIManager_Test; import com.ibm.bluemix.appid.android.internal.helpers.AuthorizationHeaderHelper_Test; +import com.ibm.bluemix.appid.android.internal.loginwidget.LoginWidgetImpl_Test; +import com.ibm.bluemix.appid.android.internal.network.AppIDRequestFactory_Test; +import com.ibm.bluemix.appid.android.internal.network.AppIDRequest_Test; import com.ibm.bluemix.appid.android.internal.preferences.JSONPreference_Test; import com.ibm.bluemix.appid.android.internal.preferences.StringPreference_Test; import com.ibm.bluemix.appid.android.internal.tokenmanager.TokenManager_Test; import com.ibm.bluemix.appid.android.internal.tokens.AbstractToken_Test; +import com.ibm.bluemix.appid.android.internal.userattributesmanager.UserAttributeManagerImpl_Test; import org.junit.runner.RunWith; import org.junit.runners.Suite; @@ -50,6 +55,11 @@ JSONPreference_Test.class, Config_Test.class, AuthorizationManager_Test.class, - TokenManager_Test.class + TokenManager_Test.class, + AuthorizationUIManager_Test.class, + UserAttributeManagerImpl_Test.class, + AppIDRequest_Test.class, + AppIDRequestFactory_Test.class, + LoginWidgetImpl_Test.class }) public class TestSuite {} diff --git a/lib/src/test/java/com/ibm/bluemix/appid/android/api/AppIDAuthorizationManager_Test.java b/lib/src/test/java/com/ibm/bluemix/appid/android/api/AppIDAuthorizationManager_Test.java index e375c6d..f3bb71e 100644 --- a/lib/src/test/java/com/ibm/bluemix/appid/android/api/AppIDAuthorizationManager_Test.java +++ b/lib/src/test/java/com/ibm/bluemix/appid/android/api/AppIDAuthorizationManager_Test.java @@ -13,6 +13,7 @@ package com.ibm.bluemix.appid.android.api; +import android.app.Activity; import android.os.Build; import com.ibm.bluemix.appid.android.api.tokens.AccessToken; @@ -25,17 +26,23 @@ import com.ibm.bluemix.appid.android.testing.helpers.Consts; import com.ibm.bluemix.appid.android.testing.mocks.HttpURLConnection_Mock; import com.ibm.mobilefirstplatform.appid_clientsdk_android.BuildConfig; +import com.ibm.mobilefirstplatform.clientsdk.android.core.api.Response; +import com.ibm.mobilefirstplatform.clientsdk.android.core.api.ResponseListener; import com.ibm.mobilefirstplatform.clientsdk.android.security.api.AppIdentity; import com.ibm.mobilefirstplatform.clientsdk.android.security.api.DeviceIdentity; import com.ibm.mobilefirstplatform.clientsdk.android.security.api.UserIdentity; +import org.json.JSONObject; import org.junit.Before; import org.junit.FixMethodOrder; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.MethodSorters; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; import org.robolectric.RobolectricTestRunner; import org.robolectric.RuntimeEnvironment; import org.robolectric.annotation.Config; @@ -47,6 +54,7 @@ import java.util.Map; +import static junit.framework.Assert.assertEquals; import static org.assertj.core.api.Java6Assertions.*; import static org.mockito.Mockito.*; @@ -182,4 +190,83 @@ public void testLogout(){ appIdAuthManager.logout(RuntimeEnvironment.application, null); verify(tokenManagerMock, times(2)).clearStoredTokens(); } + + @Test + public void obtainAuthorization_test_onAuthorizationSuccess(){ + Mockito.doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + AuthorizationListener authorizationListener = (AuthorizationListener) args[1]; + authorizationListener.onAuthorizationSuccess(accessToken,idToken); + return null; + } + }).when(authorizationManagerMock).launchAuthorizationUI(any(Activity.class), any(AuthorizationListener.class)); + + + appIdAuthManager.obtainAuthorization(Mockito.mock(Activity.class), new ResponseListener() { + @Override + public void onSuccess(Response response) { + assertEquals(response, null); + } + + @Override + public void onFailure(Response response, Throwable t, JSONObject extendedInfo) { + fail("should get to onSuccess"); + } + }, null); + } + + @Test + public void obtainAuthorization_test_onAuthorizationFailure(){ + Mockito.doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + AuthorizationListener authorizationListener = (AuthorizationListener) args[1]; + authorizationListener.onAuthorizationFailure(new AuthorizationException("test exception")); + return null; + } + }).when(authorizationManagerMock).launchAuthorizationUI(any(Activity.class), any(AuthorizationListener.class)); + + + appIdAuthManager.obtainAuthorization(Mockito.mock(Activity.class), new ResponseListener() { + @Override + public void onSuccess(Response response) { + fail("should get to onFailure"); + } + + @Override + public void onFailure(Response response, Throwable t, JSONObject extendedInfo) { + assertEquals(t.getMessage(), "test exception"); + } + }, null); + } + + @Test + public void obtainAuthorization_test_onAuthorizationCanceled(){ + Mockito.doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + AuthorizationListener authorizationListener = (AuthorizationListener) args[1]; + authorizationListener.onAuthorizationCanceled(); + return null; + } + }).when(authorizationManagerMock).launchAuthorizationUI(any(Activity.class), any(AuthorizationListener.class)); + + + appIdAuthManager.obtainAuthorization(Mockito.mock(Activity.class), new ResponseListener() { + @Override + public void onSuccess(Response response) { + fail("should get to onFailure"); + } + + @Override + public void onFailure(Response response, Throwable t, JSONObject extendedInfo) { + assertEquals(t.getMessage(), "Authorization canceled"); + } + }, null); + } + } diff --git a/lib/src/test/java/com/ibm/bluemix/appid/android/internal/authorizationmanager/AuthorizationManager_Test.java b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/authorizationmanager/AuthorizationManager_Test.java index 4263f40..789b4d9 100644 --- a/lib/src/test/java/com/ibm/bluemix/appid/android/internal/authorizationmanager/AuthorizationManager_Test.java +++ b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/authorizationmanager/AuthorizationManager_Test.java @@ -1,8 +1,19 @@ +/* + Copyright 2017 IBM Corp. + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ package com.ibm.bluemix.appid.android.internal.authorizationmanager; import android.app.Activity; import android.content.Context; -import android.content.Intent; import android.content.pm.PackageManager; import com.ibm.bluemix.appid.android.api.AppID; @@ -111,8 +122,6 @@ public void before() { when(oAuthManagerMock.getRegistrationManager()).thenReturn(registrationManager); when(appidMock.getBluemixRegionSuffix()).thenReturn(".stubPrefix"); when(mockContext.getPackageManager()).thenReturn(pmMock); - when(pmMock.resolveActivity(eq(any(Intent.class)), 0)).thenReturn(null); - when(pmMock.queryIntentActivities(eq(any(Intent.class)), 0)).thenReturn(null); when(oAuthManagerMock.getTokenManager()).thenReturn(tokenManagerMock); doAnswer(new Answer() { diff --git a/lib/src/test/java/com/ibm/bluemix/appid/android/internal/authorizationmanager/AuthorizationUIManager_Test.java b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/authorizationmanager/AuthorizationUIManager_Test.java new file mode 100644 index 0000000..c18ca82 --- /dev/null +++ b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/authorizationmanager/AuthorizationUIManager_Test.java @@ -0,0 +1,203 @@ +/* + Copyright 2017 IBM Corp. + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ +package com.ibm.bluemix.appid.android.internal.authorizationmanager; + +import android.app.Activity; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.ActivityInfo; +import android.content.pm.PackageManager; +import android.content.pm.ResolveInfo; + +import com.ibm.bluemix.appid.android.api.AuthorizationException; +import com.ibm.bluemix.appid.android.api.AuthorizationListener; +import com.ibm.bluemix.appid.android.api.tokens.AccessToken; +import com.ibm.bluemix.appid.android.api.tokens.IdentityToken; +import com.ibm.bluemix.appid.android.internal.OAuthManager; + +import org.junit.Before; +import org.junit.FixMethodOrder; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.MethodSorters; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; + +import java.util.ArrayList; +import java.util.List; + +import static com.ibm.bluemix.appid.android.internal.authorizationmanager.AuthorizationUIManager.EXTRA_REDIRECT_URL; +import static com.ibm.bluemix.appid.android.internal.authorizationmanager.AuthorizationUIManager.EXTRA_URL; +import static junit.framework.Assert.assertEquals; +import static junit.framework.Assert.fail; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.when; + +@RunWith(RobolectricTestRunner.class) +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class AuthorizationUIManager_Test { + + @Mock + private Context mockContext; + @Mock + private OAuthManager mockOAuthManager; + @Mock + private PackageManager pmMock; + @Mock + private ResolveInfo resolveInfoMock; + @Mock + private ResolveInfo resolveInfoMock2; + @Mock + private ActivityInfo activityInfoMock; + @Mock + private ActivityInfo activityInfoMock2; + @Mock + private Activity activityMock; + + private AuthorizationListener authorizationListener; + private static final String STABLE_PACKAGE = "com.android.chrome"; + private static final String BETA_PACKAGE = "com.chrome.beta"; + private static final String DEV_PACKAGE = "com.chrome.dev"; + private static final String LOCAL_PACKAGE = "com.google.android.apps.chrome"; + private Intent spyIntent = Mockito.spy(new Intent()); + private AuthorizationUIManager authorizationUIManager; + private AuthorizationUIManager authorizationUIManagerSpy; + private List resolveInfos; + + @Before + public void before(){ + MockitoAnnotations.initMocks(this); + when(mockContext.getPackageManager()).thenReturn(pmMock); + resolveInfos = new ArrayList<>(); + resolveInfoMock.activityInfo = activityInfoMock; + activityInfoMock.packageName = "com.android.chrome_test"; + resolveInfos.add(resolveInfoMock); + when(pmMock.queryIntentActivities(any(Intent.class), eq(0))).thenReturn(resolveInfos); + when(pmMock.resolveService(any(Intent.class), eq(0))).thenReturn(resolveInfoMock); + Mockito.doReturn(mockContext).when(activityMock).getApplicationContext(); + authorizationListener = new AuthorizationListener() { + @Override + public void onAuthorizationCanceled() { + fail("should get to onAuthorizationFailure"); + } + + @Override + public void onAuthorizationFailure(AuthorizationException exception) { + assertEquals(exception.getMessage(), "Could NOT find installed browser that support Chrome tabs on the device."); + } + + @Override + public void onAuthorizationSuccess(AccessToken accessToken, IdentityToken identityToken) { + fail("should get to onAuthorizationFailure"); + } + }; + authorizationUIManager = new AuthorizationUIManager(mockOAuthManager, authorizationListener, "https://serverurlTest", "https://redirectTest"); + authorizationUIManagerSpy = Mockito.spy(authorizationUIManager); + Mockito.doReturn(spyIntent).when(authorizationUIManagerSpy).createChromeTabIntent(activityMock); + resolveInfoMock2.activityInfo = activityInfoMock2; + + } + + @Test + public void launch_test() { + Mockito.reset(spyIntent); + authorizationUIManagerSpy.launch(activityMock); + Mockito.verify(spyIntent).putExtra(EXTRA_REDIRECT_URL, "https://redirectTest"); + Mockito.verify(spyIntent).putExtra(EXTRA_URL, "https://serverurlTest"); + + } + + @Test + public void launch_test_LOCAL_PACKAGE() { + Mockito.reset(spyIntent); + activityInfoMock2.packageName = LOCAL_PACKAGE; + resolveInfos.add(resolveInfoMock2); + authorizationUIManagerSpy.reset_sPackageNameToUse(); + authorizationUIManagerSpy.launch(activityMock); + Mockito.verify(spyIntent).putExtra(EXTRA_REDIRECT_URL, "https://redirectTest"); + Mockito.verify(spyIntent).putExtra(EXTRA_URL, "https://serverurlTest"); + + } + + @Test + public void launch_test_DEV_PACKAGE() { + Mockito.reset(spyIntent); + activityInfoMock2.packageName = DEV_PACKAGE; + resolveInfos.add(resolveInfoMock2); + authorizationUIManagerSpy.reset_sPackageNameToUse(); + authorizationUIManagerSpy.launch(activityMock); + Mockito.verify(spyIntent).putExtra(EXTRA_REDIRECT_URL, "https://redirectTest"); + Mockito.verify(spyIntent).putExtra(EXTRA_URL, "https://serverurlTest"); + + } + @Test + public void launch_test_BETA_PACKAGE() { + Mockito.reset(spyIntent); + activityInfoMock2.packageName = BETA_PACKAGE; + resolveInfos.add(resolveInfoMock2); + authorizationUIManagerSpy.reset_sPackageNameToUse(); + authorizationUIManagerSpy.launch(activityMock); + Mockito.verify(spyIntent).putExtra(EXTRA_REDIRECT_URL, "https://redirectTest"); + Mockito.verify(spyIntent).putExtra(EXTRA_URL, "https://serverurlTest"); + + } + @Test + public void launch_test_STABLE_PACKAGE() { + Mockito.reset(spyIntent); + activityInfoMock2.packageName = STABLE_PACKAGE; + resolveInfos.add(resolveInfoMock2); + authorizationUIManagerSpy.reset_sPackageNameToUse(); + authorizationUIManagerSpy.launch(activityMock); + Mockito.verify(spyIntent).putExtra(EXTRA_REDIRECT_URL, "https://redirectTest"); + Mockito.verify(spyIntent).putExtra(EXTRA_URL, "https://serverurlTest"); + + } + + @Test + public void launch_test_hasSpecializedHandlerIntents_test() { + Mockito.reset(spyIntent); + authorizationUIManagerSpy.reset_sPackageNameToUse(); + activityInfoMock2.packageName = STABLE_PACKAGE; + resolveInfos.add(resolveInfoMock2); + when(pmMock.resolveActivity(any(Intent.class), eq(0))).thenReturn(resolveInfoMock); + + authorizationUIManagerSpy.launch(activityMock); + Mockito.verify(spyIntent).putExtra(EXTRA_REDIRECT_URL, "https://redirectTest"); + Mockito.verify(spyIntent).putExtra(EXTRA_URL, "https://serverurlTest"); + + } + + @Test + public void launch_test_hasSpecializedHandlerIntents_return_true() { + authorizationUIManagerSpy.reset_sPackageNameToUse(); + activityInfoMock2.packageName = STABLE_PACKAGE; + resolveInfos.add(resolveInfoMock2); + IntentFilter mockFilter = Mockito.mock(IntentFilter.class); + resolveInfoMock2.filter = mockFilter; + resolveInfoMock2.activityInfo = Mockito.mock(ActivityInfo.class); + when(mockFilter.countDataAuthorities()).thenReturn(3); + when(mockFilter.countDataPaths()).thenReturn(3); + + when(pmMock.resolveActivity(any(Intent.class), eq(0))).thenReturn(resolveInfoMock); + + when(pmMock.queryIntentActivities(any(Intent.class), eq(PackageManager.GET_RESOLVED_FILTER))).thenReturn(resolveInfos); + + authorizationUIManagerSpy.launch(activityMock); + + + } +} diff --git a/lib/src/test/java/com/ibm/bluemix/appid/android/internal/loginwidget/LoginWidgetImpl_Test.java b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/loginwidget/LoginWidgetImpl_Test.java new file mode 100644 index 0000000..44a2021 --- /dev/null +++ b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/loginwidget/LoginWidgetImpl_Test.java @@ -0,0 +1,132 @@ +/* + Copyright 2017 IBM Corp. + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ +package com.ibm.bluemix.appid.android.internal.loginwidget; + +import android.app.Activity; + +import com.ibm.bluemix.appid.android.api.AuthorizationException; +import com.ibm.bluemix.appid.android.api.AuthorizationListener; +import com.ibm.bluemix.appid.android.api.tokens.AccessToken; +import com.ibm.bluemix.appid.android.api.tokens.IdentityToken; +import com.ibm.bluemix.appid.android.internal.OAuthManager; +import com.ibm.bluemix.appid.android.internal.authorizationmanager.AuthorizationManager; +import com.ibm.bluemix.appid.android.internal.tokenmanager.TokenManager; +import com.ibm.bluemix.appid.android.internal.tokens.AccessTokenImpl; +import com.ibm.bluemix.appid.android.testing.helpers.Consts; + +import org.junit.Before; +import org.junit.FixMethodOrder; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.MethodSorters; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.robolectric.RobolectricTestRunner; + +import static junit.framework.Assert.assertEquals; +import static junit.framework.Assert.fail; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.when; + +@RunWith(RobolectricTestRunner.class) +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class LoginWidgetImpl_Test { + + @Mock + private OAuthManager oAuthManager; + @Mock + private AuthorizationManager mockAuthManager; + @Mock + private TokenManager mockTokenManager; + + private static final AccessToken expectedAccessToken = new AccessTokenImpl(Consts.ACCESS_TOKEN); + private LoginWidgetImpl loginWidget; + @Before + public void before(){ + MockitoAnnotations.initMocks(this); + loginWidget = new LoginWidgetImpl(oAuthManager); + when(oAuthManager.getAuthorizationManager()).thenReturn(mockAuthManager); + when(oAuthManager.getTokenManager()).thenReturn(mockTokenManager); + when(mockTokenManager.getLatestAccessToken()).thenReturn(expectedAccessToken); + } + + @Test + public void launch_test(){ + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + AccessToken accessToken = (AccessToken) args[1]; + AuthorizationListener authorizationListener = (AuthorizationListener) args[2]; + authorizationListener.onAuthorizationSuccess(accessToken, null); + return null; + } + }).when(mockAuthManager).launchAuthorizationUI(any(Activity.class), any(AccessToken.class),any(AuthorizationListener.class)); + + + loginWidget.launch(Mockito.mock(Activity.class), new AuthorizationListener() { + @Override + public void onAuthorizationCanceled() { + fail("should get to onAuthorizationSuccess"); + } + + @Override + public void onAuthorizationFailure(AuthorizationException exception) { + fail("should get to onAuthorizationSuccess"); + } + + @Override + public void onAuthorizationSuccess(AccessToken accessToken, IdentityToken identityToken) { + assertEquals(accessToken, expectedAccessToken); + } + }, null); + } + + @Test + public void launch_test_with_access_token(){ + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + AccessToken accessToken = (AccessToken) args[1]; + AuthorizationListener authorizationListener = (AuthorizationListener) args[2]; + authorizationListener.onAuthorizationSuccess(accessToken, null); + return null; + } + }).when(mockAuthManager).launchAuthorizationUI(any(Activity.class), any(AccessToken.class),any(AuthorizationListener.class)); + + + loginWidget.launch(Mockito.mock(Activity.class), new AuthorizationListener() { + @Override + public void onAuthorizationCanceled() { + fail("should get to onAuthorizationSuccess"); + } + + @Override + public void onAuthorizationFailure(AuthorizationException exception) { + fail("should get to onAuthorizationSuccess"); + } + + @Override + public void onAuthorizationSuccess(AccessToken accessToken, IdentityToken identityToken) { + assertEquals(accessToken.getRaw(), expectedAccessToken.getRaw()); + } + }, expectedAccessToken.getRaw()); + } +} diff --git a/lib/src/test/java/com/ibm/bluemix/appid/android/internal/network/AppIDRequestFactory_Test.java b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/network/AppIDRequestFactory_Test.java new file mode 100644 index 0000000..00c075a --- /dev/null +++ b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/network/AppIDRequestFactory_Test.java @@ -0,0 +1,30 @@ +/* + Copyright 2017 IBM Corp. + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ +package com.ibm.bluemix.appid.android.internal.network; + +import org.junit.Test; + +import static junit.framework.Assert.assertEquals; + +public class AppIDRequestFactory_Test { + + private String testUrl = "testUrl"; + private String testMethod = "testMethod"; + @Test + public void createRequest_test() { + AppIDRequestFactory appIDRequestFactory = new AppIDRequestFactory(); + AppIDRequest appIDRequest = appIDRequestFactory.createRequest(testUrl, testMethod); + assertEquals(appIDRequest.getMethod(), testMethod); + assertEquals(appIDRequest.getUrl(), testUrl); + } +} diff --git a/lib/src/test/java/com/ibm/bluemix/appid/android/internal/network/AppIDRequest_Test.java b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/network/AppIDRequest_Test.java new file mode 100644 index 0000000..e2fe9ee --- /dev/null +++ b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/network/AppIDRequest_Test.java @@ -0,0 +1,124 @@ +/* + Copyright 2017 IBM Corp. + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ +package com.ibm.bluemix.appid.android.internal.network; + +import com.ibm.bluemix.appid.android.api.tokens.AccessToken; +import com.ibm.bluemix.appid.android.internal.tokens.AccessTokenImpl; +import com.ibm.bluemix.appid.android.testing.helpers.Consts; +import com.ibm.mobilefirstplatform.clientsdk.android.core.api.Response; +import com.ibm.mobilefirstplatform.clientsdk.android.core.api.ResponseListener; + +import org.json.JSONObject; +import org.junit.FixMethodOrder; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.MethodSorters; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.robolectric.RobolectricTestRunner; +import java.util.List; +import java.util.Map; + +import static junit.framework.Assert.assertEquals; +import static junit.framework.Assert.fail; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyString; + +@RunWith(RobolectricTestRunner.class) +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class AppIDRequest_Test { + + AppIDRequestFactory appIDRequestFactory = new AppIDRequestFactory(); + AppIDRequest appIDRequest = appIDRequestFactory.createRequest("testUrl", "testMethod"); + AppIDRequest spyAppIDRequest = Mockito.spy(appIDRequest); + private static final AccessToken expectedAccessToken = new AccessTokenImpl(Consts.ACCESS_TOKEN); + + @Test + public void send_test(){ + + Mockito.doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + String header = (String) args[0]; + if (!header.equals("Authorization")) { + fail("header is not Authorization"); + } + return null; + } + }).when(spyAppIDRequest).removeHeaders(anyString()); + + Mockito.doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + String header = (String) args[0]; + String bearerPlusToken = (String) args[1]; + if (!header.equals("Authorization")) { + fail("header is not Authorization"); + } + if (!bearerPlusToken.equals("Bearer " + expectedAccessToken.getRaw())) { + fail("addHeader params mismatch"); + } + return null; + } + }).when(spyAppIDRequest).addHeader(anyString(),anyString()); + + + final Response testReponse = new Response() { + @Override + public int getStatus() { + return 200; + } + + @Override + public String getResponseText() { + return null; + } + + @Override + public byte[] getResponseBytes() { + return new byte[0]; + } + + @Override + public Map> getHeaders() { + return null; + } + }; + + Mockito.doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + responseListener.onSuccess(testReponse); + return null; + } + }).when(spyAppIDRequest).send(any(ResponseListener.class)); + + + spyAppIDRequest.send(new ResponseListener() { + @Override + public void onSuccess(Response response) { + assertEquals(response.getStatus(), 200); + } + + @Override + public void onFailure(Response response, Throwable t, JSONObject extendedInfo) { + fail("should get to onSuccess"); + } + }, null, expectedAccessToken); + } +} diff --git a/lib/src/test/java/com/ibm/bluemix/appid/android/internal/tokenmanager/TokenManager_Test.java b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/tokenmanager/TokenManager_Test.java index 3d944c6..f664a44 100644 --- a/lib/src/test/java/com/ibm/bluemix/appid/android/internal/tokenmanager/TokenManager_Test.java +++ b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/tokenmanager/TokenManager_Test.java @@ -1,3 +1,15 @@ +/* + Copyright 2017 IBM Corp. + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ package com.ibm.bluemix.appid.android.internal.tokenmanager; import com.ibm.bluemix.appid.android.api.AppID; @@ -46,12 +58,8 @@ import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.when; -/** - * Created by rotembr on 01/06/2017. - */ @RunWith(RobolectricTestRunner.class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) -@PrepareForTest(Signature.class) public class TokenManager_Test { @Mock diff --git a/lib/src/test/java/com/ibm/bluemix/appid/android/internal/userattributesmanager/UserAttributeManagerImpl_Test.java b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/userattributesmanager/UserAttributeManagerImpl_Test.java new file mode 100644 index 0000000..ecaf5ef --- /dev/null +++ b/lib/src/test/java/com/ibm/bluemix/appid/android/internal/userattributesmanager/UserAttributeManagerImpl_Test.java @@ -0,0 +1,684 @@ +/* + Copyright 2017 IBM Corp. + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ +package com.ibm.bluemix.appid.android.internal.userattributesmanager; + +import android.content.Context; +import android.content.pm.PackageManager; + +import com.ibm.bluemix.appid.android.api.AppID; +import com.ibm.bluemix.appid.android.api.tokens.AccessToken; +import com.ibm.bluemix.appid.android.api.userattributes.UserAttributeResponseListener; +import com.ibm.bluemix.appid.android.api.userattributes.UserAttributesException; +import com.ibm.bluemix.appid.android.internal.network.AppIDRequest; +import com.ibm.bluemix.appid.android.internal.tokenmanager.TokenManager; +import com.ibm.bluemix.appid.android.internal.tokens.AccessTokenImpl; +import com.ibm.bluemix.appid.android.testing.helpers.Consts; +import com.ibm.mobilefirstplatform.clientsdk.android.core.api.Response; +import com.ibm.mobilefirstplatform.clientsdk.android.core.api.ResponseListener; +import com.squareup.okhttp.RequestBody; + +import org.json.JSONException; +import org.json.JSONObject; +import org.junit.Before; +import org.junit.FixMethodOrder; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.MethodSorters; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.robolectric.RobolectricTestRunner; + +import java.util.List; +import java.util.Map; + +import static junit.framework.Assert.assertEquals; +import static junit.framework.Assert.fail; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyString; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.when; + +@RunWith(RobolectricTestRunner.class) +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class UserAttributeManagerImpl_Test { + + @Mock + private RequestBody stubRequestBody; + @Mock + private AppIDRequest stubRequest; + @Mock + private AppIDRequest specificStubRequest; + @Mock + private TokenManager tokenManagerMock; + @Mock + private Context mockContext; + @Mock + private PackageManager pmMock; + + private UserAttributeManagerImpl userAttributeManagerSpy; + private static final AccessToken expectedAccessToken = new AccessTokenImpl(Consts.ACCESS_TOKEN); + + @Before + public void before(){ + MockitoAnnotations.initMocks(this); + UserAttributeManagerImpl userAttributeManager = new UserAttributeManagerImpl(tokenManagerMock); + when(tokenManagerMock.getLatestAccessToken()).thenReturn(expectedAccessToken); + userAttributeManagerSpy = Mockito.spy(userAttributeManager); + Mockito.doReturn(stubRequest).when(userAttributeManagerSpy).createAppIDRequest(anyString(), anyString()); + when(mockContext.getApplicationContext()).thenReturn(mockContext); + when(mockContext.getPackageManager()).thenReturn(pmMock); + AppID.getInstance().initialize(mockContext,"00001111-1111-1111-1111-123456789012",".test"); + } + + @Test + public void getAllAttributes_happy_flow() { + + final Response testReponse = new Response() { + @Override + public int getStatus() { + return 200; + } + + @Override + public String getResponseText() { + return "{\"age\": 30, \"email\":\"test@ibm.com\"}"; + } + + @Override + public byte[] getResponseBytes() { + return new byte[0]; + } + + @Override + public Map> getHeaders() { + return null; + } + }; + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + responseListener.onSuccess(testReponse); + return null; + } + }).when(stubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + userAttributeManagerSpy.getAllAttributes(expectedAccessToken, new UserAttributeResponseListener() { + @Override + public void onSuccess(JSONObject attributes) { + try { + assertEquals(attributes.getInt("age"), 30); + assertEquals(attributes.getString("email"), "test@ibm.com"); + } catch (JSONException e) { + e.printStackTrace(); + } + + } + + @Override + public void onFailure(UserAttributesException e) { + fail("should get to onSuccess"); + } + }); + + } + + @Test + public void getAllAttributes_happy_flow_null_response_text() { + + final Response testReponse = new Response() { + @Override + public int getStatus() { + return 200; + } + + @Override + public String getResponseText() { + return null; + } + + @Override + public byte[] getResponseBytes() { + return new byte[0]; + } + + @Override + public Map> getHeaders() { + return null; + } + }; + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + responseListener.onSuccess(testReponse); + return null; + } + }).when(stubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + userAttributeManagerSpy.getAllAttributes(expectedAccessToken, new UserAttributeResponseListener() { + @Override + public void onSuccess(JSONObject attributes) { + assertEquals(attributes.toString(), "{}"); + } + + @Override + public void onFailure(UserAttributesException e) { + fail("should get to onSuccess"); + } + }); + + } + + @Test + public void getAllAttributes_happy_flow_empty_response_text() { + + final Response testReponse = new Response() { + @Override + public int getStatus() { + return 200; + } + + @Override + public String getResponseText() { + return ""; + } + + @Override + public byte[] getResponseBytes() { + return new byte[0]; + } + + @Override + public Map> getHeaders() { + return null; + } + }; + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + responseListener.onSuccess(testReponse); + return null; + } + }).when(stubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + userAttributeManagerSpy.getAllAttributes(expectedAccessToken, new UserAttributeResponseListener() { + @Override + public void onSuccess(JSONObject attributes) { + assertEquals(attributes.toString(), "{}"); + } + + @Override + public void onFailure(UserAttributesException e) { + fail("should get to onSuccess"); + } + }); + + } + + @Test + public void getAllAttributes_request_failure_json_format() { + + final Response testReponse = new Response() { + @Override + public int getStatus() { + return 200; + } + + @Override + public String getResponseText() { + return "56"; + } + + @Override + public byte[] getResponseBytes() { + return new byte[0]; + } + + @Override + public Map> getHeaders() { + return null; + } + }; + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + responseListener.onSuccess(testReponse); + return null; + } + }).when(stubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + userAttributeManagerSpy.getAllAttributes(expectedAccessToken, new UserAttributeResponseListener() { + @Override + public void onSuccess(JSONObject attributes) { + fail("should get to onFailure"); + + } + + @Override + public void onFailure(UserAttributesException e) { + assertEquals(e.getError(), UserAttributesException.Error.JSON_PARSE_ERROR); + } + }); + } + + @Test + public void getAllAttributes_request_failure() { + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + responseListener.onFailure(null, null, null); + return null; + } + }).when(stubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + userAttributeManagerSpy.getAllAttributes(expectedAccessToken, new UserAttributeResponseListener() { + @Override + public void onSuccess(JSONObject attributes) { + fail("should get to onFailure"); + + } + + @Override + public void onFailure(UserAttributesException e) { + assertEquals(e.getError(), UserAttributesException.Error.FAILED_TO_CONNECT); + } + }); + } + + @Test + public void getAllAttributes_request_failure_401() { + final Response testReponse = new Response() { + @Override + public int getStatus() { + return 401; + } + + @Override + public String getResponseText() { + return null; + } + + @Override + public byte[] getResponseBytes() { + return new byte[0]; + } + + @Override + public Map> getHeaders() { + return null; + } + }; + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + responseListener.onFailure(testReponse, null, null); + return null; + } + }).when(stubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + userAttributeManagerSpy.getAllAttributes(expectedAccessToken, new UserAttributeResponseListener() { + @Override + public void onSuccess(JSONObject attributes) { + fail("should get to onFailure"); + + } + + @Override + public void onFailure(UserAttributesException e) { + assertEquals(e.getError(), UserAttributesException.Error.UNAUTHORIZED); + } + }); + } + + @Test + public void getAllAttributes_request_failure_404() { + final Response testReponse = new Response() { + @Override + public int getStatus() { + return 404; + } + + @Override + public String getResponseText() { + return null; + } + + @Override + public byte[] getResponseBytes() { + return new byte[0]; + } + + @Override + public Map> getHeaders() { + return null; + } + }; + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + responseListener.onFailure(testReponse, null, null); + return null; + } + }).when(stubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + userAttributeManagerSpy.getAllAttributes(expectedAccessToken, new UserAttributeResponseListener() { + @Override + public void onSuccess(JSONObject attributes) { + fail("should get to onFailure"); + + } + + @Override + public void onFailure(UserAttributesException e) { + assertEquals(e.getError(), UserAttributesException.Error.NOT_FOUND); + } + }); + } + + @Test + public void getAllAttributes_happy_flow_no_token_supply() { + + final Response testReponse = new Response() { + @Override + public int getStatus() { + return 200; + } + + @Override + public String getResponseText() { + return "{\"age\": 30, \"email\":\"test@ibm.com\"}"; + } + + @Override + public byte[] getResponseBytes() { + return new byte[0]; + } + + @Override + public Map> getHeaders() { + return null; + } + }; + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + responseListener.onSuccess(testReponse); + return null; + } + }).when(stubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + userAttributeManagerSpy.getAllAttributes(new UserAttributeResponseListener() { + @Override + public void onSuccess(JSONObject attributes) { + try { + assertEquals(attributes.getInt("age"), 30); + assertEquals(attributes.getString("email"), "test@ibm.com"); + } catch (JSONException e) { + e.printStackTrace(); + } + + } + + @Override + public void onFailure(UserAttributesException e) { + fail("should get to onSuccess"); + } + }); + + } + + @Test + public void setAttribute_no_token_supply() { + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + responseListener.onFailure(null, null, null); + return null; + } + }).when(stubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + final Response testReponse = new Response() { + @Override + public int getStatus() { + return 200; + } + + @Override + public String getResponseText() { + return "{\"name\": \"testName\", \"value\":\"testValue\"}"; + } + + @Override + public byte[] getResponseBytes() { + return new byte[0]; + } + + @Override + public Map> getHeaders() { + return null; + } + }; + + Mockito.doReturn(specificStubRequest).when(userAttributeManagerSpy).createAppIDRequest(eq("https://appid-profiles.test/api/v1/attributes/testName"), eq(AppIDRequest.PUT)); + Mockito.doReturn(stubRequestBody).when(userAttributeManagerSpy).createRequestBody(eq("testValue")); + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + if ((RequestBody)args[1] != stubRequestBody){ + responseListener.onFailure(null,null,null); + } + responseListener.onSuccess(testReponse); + return null; + } + }).when(specificStubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + + + userAttributeManagerSpy.setAttribute("testName","testValue",new UserAttributeResponseListener() { + @Override + public void onSuccess(JSONObject attributes) { + try { + assertEquals(attributes.getString("name"), "testName"); + assertEquals(attributes.getString("value"), "testValue"); + } catch (JSONException e) { + fail(e.getMessage()); + e.printStackTrace(); + } + + } + + @Override + public void onFailure(UserAttributesException e) { + fail("should get to onSuccess"); + } + }); + + } + + @Test + public void getAttribute_no_token_supply() { + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + responseListener.onFailure(null, null, null); + return null; + } + }).when(stubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + final Response testReponse = new Response() { + @Override + public int getStatus() { + return 200; + } + + @Override + public String getResponseText() { + return "{\"name\": \"testName\", \"value\":\"testValue\"}"; + } + + @Override + public byte[] getResponseBytes() { + return new byte[0]; + } + + @Override + public Map> getHeaders() { + return null; + } + }; + + Mockito.doReturn(specificStubRequest).when(userAttributeManagerSpy).createAppIDRequest(eq("https://appid-profiles.test/api/v1/attributes/testName"), eq(AppIDRequest.GET)); + Mockito.doReturn(stubRequestBody).when(userAttributeManagerSpy).createRequestBody((String) eq(null)); + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + if ((RequestBody)args[1] != null) { + responseListener.onFailure(null,null,null); + } + responseListener.onSuccess(testReponse); + return null; + } + }).when(specificStubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + + userAttributeManagerSpy.getAttribute("testName",new UserAttributeResponseListener() { + @Override + public void onSuccess(JSONObject attributes) { + try { + assertEquals(attributes.getString("name"), "testName"); + assertEquals(attributes.getString("value"), "testValue"); + } catch (JSONException e) { + fail(e.getMessage()); + e.printStackTrace(); + } + + } + + @Override + public void onFailure(UserAttributesException e) { + fail("should get to onSuccess"); + } + }); + + } + + @Test + public void deleteAttribute_no_token_supply() { + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + responseListener.onFailure(null, null, null); + return null; + } + }).when(stubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + final Response testReponse = new Response() { + @Override + public int getStatus() { + return 200; + } + + @Override + public String getResponseText() { + return "{\"name\": \"testName\", \"value\":\"testValue\"}"; + } + + @Override + public byte[] getResponseBytes() { + return new byte[0]; + } + + @Override + public Map> getHeaders() { + return null; + } + }; + + Mockito.doReturn(specificStubRequest).when(userAttributeManagerSpy).createAppIDRequest(eq("https://appid-profiles.test/api/v1/attributes/testName"), eq(AppIDRequest.DELETE)); + Mockito.doReturn(stubRequestBody).when(userAttributeManagerSpy).createRequestBody((String) eq(null)); + + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + ResponseListener responseListener = (ResponseListener) args[0]; + if ((RequestBody)args[1] != null) { + responseListener.onFailure(null,null,null); + } + responseListener.onSuccess(testReponse); + return null; + } + }).when(specificStubRequest).send(any(ResponseListener.class), any(RequestBody.class), eq(expectedAccessToken)); + + + userAttributeManagerSpy.deleteAttribute("testName",new UserAttributeResponseListener() { + @Override + public void onSuccess(JSONObject attributes) { + try { + assertEquals(attributes.getString("name"), "testName"); + assertEquals(attributes.getString("value"), "testValue"); + } catch (JSONException e) { + fail(e.getMessage()); + e.printStackTrace(); + } + + } + + @Override + public void onFailure(UserAttributesException e) { + fail("should get to onSuccess"); + } + }); + + } +}