@Test public void testNetworkChangeReceiver() throws Exception { latch = new CountDownLatch(1); NetworkConnectionListener listener = new NetworkConnectionListener() { @Override public void networkChanged(NetworkConnectionType newConnection) { latch.countDown(); } }; NetworkMonitor mockedMonitor = mock(NetworkMonitor.class); when(mockedMonitor.getCurrentConnectionType()).thenReturn(NetworkConnectionType.WIFI); Intent mockedIntent = mock(Intent.class); when(mockedIntent.getAction()).thenReturn(ConnectivityManager.CONNECTIVITY_ACTION); NetworkMonitor.NetworkChangeReceiver receiver = mockedMonitor.new NetworkChangeReceiver(listener); receiver.onReceive(new MockContext(), mockedIntent); assertTrue(latch.await(100, TimeUnit.MILLISECONDS)); }
@Before public void setup() { MockitoAnnotations.initMocks(this); WitchTestUtils.testInit(core); items.add(EXISTING_BINDER_ITEM_POSITION, itemWithBinder); items.add(NON_EXISTING_BINDER_ITEM_POSITION, itemWithoutBinder); // Layout inflater stuff when(itemView.getTag(anyInt())).thenReturn(tagContainer); emptyViewHolder = new EmptyViewHolder(itemView); when(inflater.inflate(anyInt(), any(ViewGroup.class), anyBoolean())).thenReturn(itemView); MockContext context = mock(MockContext.class); when(context.getSystemService(eq(Service.LAYOUT_INFLATER_SERVICE))).thenReturn(inflater); when(parent.getContext()).thenReturn(context); List<RecyclerViewBinderAdapter.Binder<?>> binders = new ArrayList<>(); binders.add(itemBinder); adapter = new TestRecyclerViewBinderAdapter<>(items, binders); }
@Test public void testGetFileDirFailure() { EspScreenshotTool espScreenshotTool = new EspScreenshotTool() { @Override protected Context getTargetContext() { return new MockContext() { @Override public File getFilesDir() { // may happen when storage is not setup properly on emulator return null; } }; } }; exception.expect(IllegalStateException.class); exception.expectMessage("could not find directory to store screenshot"); espScreenshotTool.takeWithNameInternal("does not work"); }
@Test public void beginAuthorizationShouldCallUriParse() throws Exception { UpholdClient.initialize(new MockSharedPreferencesContext()); UpholdClient upholdClient = new UpholdClient(); ArrayList<String> scopes = new ArrayList<String>() {{ add("foo"); }}; PowerMockito.mockStatic(TextUtils.class); PowerMockito.when(TextUtils.join(" ", scopes)).thenReturn("foo"); PowerMockito.mockStatic(Uri.class); upholdClient.beginAuthorization(new MockContext(), "foo", scopes, "bar"); PowerMockito.verifyStatic(); Uri.parse(String.format("%s/authorize/foo?scope=foo&state=bar", BuildConfig.AUTHORIZATION_SERVER_URL)); }
private Job setupNetworkRequirement(JobRequest.NetworkType requirement, boolean connected, int networkType, boolean roaming) { NetworkInfo networkInfo = mock(NetworkInfo.class); when(networkInfo.isConnected()).thenReturn(connected); when(networkInfo.isConnectedOrConnecting()).thenReturn(connected); when(networkInfo.getType()).thenReturn(networkType); when(networkInfo.isRoaming()).thenReturn(roaming); ConnectivityManager connectivityManager = mock(ConnectivityManager.class); when(connectivityManager.getActiveNetworkInfo()).thenReturn(networkInfo); Context context = mock(MockContext.class); when(context.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(connectivityManager); JobRequest request = mock(JobRequest.class); when(request.requiredNetworkType()).thenReturn(requirement); Job.Params params = mock(Job.Params.class); when(params.getRequest()).thenReturn(request); Job job = spy(new DummyJobs.SuccessJob()); when(job.getParams()).thenReturn(params); doReturn(context).when(job).getContext(); return job; }
/** * @return A mocked context which returns a spy of {@link RuntimeEnvironment#application} in * {@link Context#getApplicationContext()}. */ public static Context createMockContext() { // otherwise the JobScheduler isn't supported we check if the service is enable // Robolectric doesn't parse services from the manifest, see https://github.com/robolectric/robolectric/issues/416 PackageManager packageManager = mock(PackageManager.class); when(packageManager.queryBroadcastReceivers(any(Intent.class), anyInt())).thenReturn(Collections.singletonList(new ResolveInfo())); ResolveInfo resolveInfo = new ResolveInfo(); resolveInfo.serviceInfo = new ServiceInfo(); resolveInfo.serviceInfo.permission = "android.permission.BIND_JOB_SERVICE"; when(packageManager.queryIntentServices(any(Intent.class), anyInt())).thenReturn(Collections.singletonList(resolveInfo)); Context context = spy(RuntimeEnvironment.application); when(context.getPackageManager()).thenReturn(packageManager); when(context.getApplicationContext()).thenReturn(context); Context mockContext = mock(MockContext.class); when(mockContext.getApplicationContext()).thenReturn(context); return mockContext; }
@Test public void testNetworkStateMeteredNotRoaming() { NetworkInfo networkInfo = mock(NetworkInfo.class); when(networkInfo.isConnected()).thenReturn(true); when(networkInfo.isConnectedOrConnecting()).thenReturn(true); when(networkInfo.getType()).thenReturn(ConnectivityManager.TYPE_MOBILE); when(networkInfo.isRoaming()).thenReturn(false); ConnectivityManager connectivityManager = mock(ConnectivityManager.class); when(connectivityManager.getActiveNetworkInfo()).thenReturn(networkInfo); Context context = mock(MockContext.class); when(context.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(connectivityManager); assertThat(Device.getNetworkType(context)).isEqualTo(JobRequest.NetworkType.NOT_ROAMING); }
@Test public void testNetworkStateRoaming() { NetworkInfo networkInfo = mock(NetworkInfo.class); when(networkInfo.isConnected()).thenReturn(true); when(networkInfo.isConnectedOrConnecting()).thenReturn(true); when(networkInfo.getType()).thenReturn(ConnectivityManager.TYPE_MOBILE); when(networkInfo.isRoaming()).thenReturn(true); ConnectivityManager connectivityManager = mock(ConnectivityManager.class); when(connectivityManager.getActiveNetworkInfo()).thenReturn(networkInfo); Context context = mock(MockContext.class); when(context.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(connectivityManager); assertThat(Device.getNetworkType(context)).isEqualTo(JobRequest.NetworkType.CONNECTED); }
@Test public void testNetworkStateWifiAndMobile() { NetworkInfo networkInfo = mock(NetworkInfo.class); when(networkInfo.isConnected()).thenReturn(true); when(networkInfo.isConnectedOrConnecting()).thenReturn(true); when(networkInfo.getType()).thenReturn(ConnectivityManager.TYPE_WIFI); when(networkInfo.isRoaming()).thenReturn(false); ConnectivityManager connectivityManager = mock(ConnectivityManager.class); when(connectivityManager.getActiveNetworkInfo()).thenReturn(networkInfo); Context context = mock(MockContext.class); when(context.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(connectivityManager); assertThat(Device.getNetworkType(context)).isEqualTo(JobRequest.NetworkType.UNMETERED); }
@Test public void testNetworkStateWifiAndRoaming() { NetworkInfo networkInfo = mock(NetworkInfo.class); when(networkInfo.isConnected()).thenReturn(true); when(networkInfo.isConnectedOrConnecting()).thenReturn(true); when(networkInfo.getType()).thenReturn(ConnectivityManager.TYPE_WIFI); when(networkInfo.isRoaming()).thenReturn(true); ConnectivityManager connectivityManager = mock(ConnectivityManager.class); when(connectivityManager.getActiveNetworkInfo()).thenReturn(networkInfo); Context context = mock(MockContext.class); when(context.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(connectivityManager); assertThat(Device.getNetworkType(context)).isEqualTo(JobRequest.NetworkType.UNMETERED); }
@Test public void testStartMonitoringNetworkChanges() throws Exception { latch = new CountDownLatch(1); class TestContext extends MockContext { @Override public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) { assertTrue(receiver instanceof NetworkMonitor.NetworkChangeReceiver); latch.countDown(); return null; } } Context context = new TestContext(); NetworkMonitor networkMonitor = new NetworkMonitor(context, getNetworkListener()); networkMonitor.startMonitoringNetworkChanges(); assertTrue(latch.await(100, TimeUnit.MILLISECONDS)); }
@Test public void testStopMonitoringNetworkChanges() throws Exception { latch = new CountDownLatch(1); class TestContext extends MockContext { @Override public void unregisterReceiver(BroadcastReceiver receiver) { assertTrue(receiver instanceof NetworkMonitor.NetworkChangeReceiver); latch.countDown(); } } Context context = new TestContext(); NetworkMonitor networkMonitor = new NetworkMonitor(context, getNetworkListener()); networkMonitor.startMonitoringNetworkChanges(); networkMonitor.stopMonitoringNetworkChanges(); assertTrue(latch.await(100, TimeUnit.MILLISECONDS)); }
@Test public void testStopMonitoringNetworkChangesWithNullListener() { class TestContext extends MockContext { @Override public void unregisterReceiver(BroadcastReceiver receiver) { fail("Should not have a receiver without a NetworkChangeListener given to NetworkMonitor."); } } // Test with null Listener Context context = new TestContext(); NetworkMonitor networkMonitor = new NetworkMonitor(context, null); networkMonitor.startMonitoringNetworkChanges(); networkMonitor.stopMonitoringNetworkChanges(); // Test misuse of the API context = new TestContext(); networkMonitor = new NetworkMonitor(context, null); networkMonitor.stopMonitoringNetworkChanges(); networkMonitor.stopMonitoringNetworkChanges(); networkMonitor.stopMonitoringNetworkChanges(); }
public void testSimpleOperationNotifiesChangeOnSuccess() { final AssertionLatch latch = new AssertionLatch(1); final MockContext context = new MockContext() { @Override public ContentResolver getContentResolver() { return new MockContentResolver() { @Override public void notifyChange(final Uri u, final ContentObserver o) { latch.countDown(); } }; } }; final TestSimpleOperation operation = new TestSimpleOperation(Uri.EMPTY); operation.onSuccess(context, null); latch.assertComplete(); }
@Test public void JsonDataToBirthdayConverterTest() throws Exception { String response = "{\"Data\":[{\"Birthday\":{\"Id\":0,\"Name\":\"Jonas Schubert\",\"Group\":\"Family\",\"RemindMe\":0,\"SentMail\":0,\"Date\":{\"Day\":2,\"Month\":1,\"Year\":1990}}},{\"Birthday\":{\"Id\":1,\"Name\":\"Artur Rychter\",\"Group\":\"Friends\",\"RemindMe\":1,\"SentMail\":0,\"Date\":{\"Day\":21,\"Month\":3,\"Year\":1990}}}]} "; MockContext mockContext = new MockContext(); SerializableList<LucaBirthday> birthdayList = JsonDataToBirthdayConverter.getInstance().GetList(response, mockContext); assertNotNull(birthdayList); assertEquals(birthdayList.getSize(), 2); assertEquals(birthdayList.getValue(0).GetName(), "Jonas Schubert"); }
@Before public void setup() { swipeLayout = new SwipeLayout(new MockContext()); orientationStrategy = mock(OrientationStrategy.class); OrientationStrategyFactory orientationStrategyFactory = new OrientationStrategyFactory() { @Override public OrientationStrategy make(View view) { return orientationStrategy; } }; swipeLayout.setOrientation(orientationStrategyFactory); verifyNoMoreInteractions(orientationStrategy); }
@Before public void setup() { ClientProperties.setApplicationContext(new MockContext() { @Override public PackageManager getPackageManager() { return new TestPackageManager(); } }); }
@Test public void login() throws IOException { Context context = new MockContext(); Observable<ApiResult<LoginData>> observable= bookRetrofit.getAccountApi().login("18301441595", "123456"); observable.observeOn(Schedulers.immediate()) .subscribeOn(Schedulers.immediate()) .subscribe(observer); }
@Test public void testGetInstance() { MockContext context = mock(MockContext.class); IronBeast ironBeast = IronBeast.getInstance(context); IronBeastTracker tracker1 = ironBeast.newTracker("token1"); IronBeastTracker tracker2 = ironBeast.newTracker("token1"); assertTrue("should not initialized new tracker with the same token", tracker1 == tracker2); IronBeastTracker tracker3 = ironBeast.newTracker("token2"); assertTrue("should initialized new tracker", tracker1 != tracker3 || tracker2 != tracker3); }
@Before public void setUp() throws Exception { activityClassManagerFactory = new ActivityClassManagerFactory(); context = mock(MockContext.class); callback = mock(ContactsCallback.class); prefManager = mock(ContactsPreferenceManager.class); digitsEventCollector = mock(DigitsEventCollector.class); callbackCaptor = ArgumentCaptor.forClass(ContactsClient.FoundContactsCallbackWrapper.class); fabric = mock(Fabric.class); activity = mock(Activity.class); intentArgumentCaptor = ArgumentCaptor.forClass(Intent.class); sandboxConfig = mock(SandboxConfig.class); when(digits.getContext()).thenReturn(context); when(context.getPackageName()).thenReturn(getClass().getPackage().toString()); when(digits.getActivityClassManager()).thenReturn(new ActivityClassManagerImp()); when(digits.getFabric()).thenReturn(fabric); when(fabric.getCurrentActivity()).thenReturn(activity); when(activity.isFinishing()).thenReturn(false); when(sandboxConfig.isMode(SandboxConfig.Mode.DEFAULT)).thenReturn(false); sdkService = mock(ApiInterface.class); apiClientManager = mock(DigitsApiClientManager.class); when(apiClientManager.getService()).thenReturn(sdkService); contactsClient = new ContactsClient(digits, apiClientManager, prefManager, activityClassManagerFactory, sandboxConfig, digitsEventCollector); activityComponent = new ComponentName(context, ContactsActivity.class.getName()); serviceComponent = new ComponentName(context, ContactsUploadService.class.getName()); }
@Before public void setUp() throws Exception { controller = new ContactsControllerImpl(); context = mock(MockContext.class); intentCaptor = ArgumentCaptor.forClass(Intent.class); when(context.getPackageName()).thenReturn(ContactsUploadService.class.getPackage() .toString()); }
@Before public void setUp() throws Exception { context = mock(MockContext.class); contentResolver = mock(ContentResolver.class); cursor = createCursor(); when(contentResolver.query(any(Uri.class), any(String[].class), any(String.class), any (String[].class), any(String.class))).thenReturn(cursor); when(context.getContentResolver()).thenReturn(contentResolver); }
private Context mockContext() { SharedPreferences preferences = mock(SharedPreferences.class); when(preferences.getStringSet(anyString(), ArgumentMatchers.<String>anySet())).thenReturn(new HashSet<String>()); Context context = mock(MockContext.class); when(context.getApplicationContext()).thenReturn(context); when(context.getSharedPreferences(anyString(), anyInt())).thenReturn(preferences); return context; }
@Test public void testNetworkStateNotConnectedWithNullNetworkInfo() { ConnectivityManager connectivityManager = mock(ConnectivityManager.class); Context context = mock(MockContext.class); when(context.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(connectivityManager); assertThat(Device.getNetworkType(context)).isEqualTo(JobRequest.NetworkType.ANY); }
@Test public void testNetworkStateNotConnected() { NetworkInfo networkInfo = mock(NetworkInfo.class); when(networkInfo.isConnected()).thenReturn(false); when(networkInfo.isConnectedOrConnecting()).thenReturn(false); ConnectivityManager connectivityManager = mock(ConnectivityManager.class); when(connectivityManager.getActiveNetworkInfo()).thenReturn(networkInfo); Context context = mock(MockContext.class); when(context.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(connectivityManager); assertThat(Device.getNetworkType(context)).isEqualTo(JobRequest.NetworkType.ANY); }
@Test public void testNetworkStateUnmeteredWifi() { NetworkInfo networkInfo = mock(NetworkInfo.class); when(networkInfo.isConnected()).thenReturn(true); when(networkInfo.isConnectedOrConnecting()).thenReturn(true); when(networkInfo.getType()).thenReturn(ConnectivityManager.TYPE_WIFI); ConnectivityManager connectivityManager = mock(ConnectivityManager.class); when(connectivityManager.getActiveNetworkInfo()).thenReturn(networkInfo); Context context = mock(MockContext.class); when(context.getSystemService(Context.CONNECTIVITY_SERVICE)).thenReturn(connectivityManager); assertThat(Device.getNetworkType(context)).isEqualTo(JobRequest.NetworkType.UNMETERED); }
@Test public void testConstructor() { NetworkMonitor networkMonitor = new NetworkMonitor(new MockContext(), getNetworkListener()); assertNotNull(networkMonitor.getNetworkReceiver()); networkMonitor = new NetworkMonitor(new MockContext(), null); assertNull(networkMonitor.getNetworkReceiver()); }
@Test public void testStartMonitoringNetworkChangesWithNullListener() { class TestContext extends MockContext { @Override public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) { fail("Should not have registered a receiver without a NetworkChangeListener given to NetworkMonitor."); return null; } } Context context = new TestContext(); NetworkMonitor networkMonitor = new NetworkMonitor(context, null); networkMonitor.startMonitoringNetworkChanges(); }
public void testSimpleOperationInsertsDataOnSuccess() throws Exception { final AssertionLatch latch = new AssertionLatch(1); final MockContext context = new MockContextWithProvider(new MockContentProvider() { @Override public int bulkInsert(Uri u, ContentValues[] v) { latch.countDown(); assertEquals(URI, u); return 0; } }); final TestSimpleOperation operation = new TestSimpleOperation(URI); operation.onPostExecute(context, new ContentValues[0]); latch.assertComplete(); }
@Override protected void setUp() throws Exception { super.setUp(); TestSetup.setupMockito(this); Context mockContext = mock(MockContext.class); WifiManager wm = mock(WifiManager.class); when(mockContext.getSystemService(Context.WIFI_SERVICE)).thenReturn(wm); WifiInfo info = mock(WifiInfo.class); when(info.getMacAddress()) .thenReturn("1") .thenReturn("2"); when(wm.getConnectionInfo()).thenReturn(info); identifier = new UniqueIdentifier(mockContext); }
public void testShareFromIntent() throws PackageManager.NameNotFoundException { final String appName = "foobar_app"; final Item item = Mockito.mock(Item.class); final MockAppDataCache appDataCache = Mockito.mock(MockAppDataCache.class); final PackageManager packageManager = Mockito.mock(PackageManager.class); final ActivityInfo activityInfo = Mockito.mock(ActivityInfo.class); final Context context = Mockito.mock(MockContext.class); final ComponentName cn = new ComponentName("foo", "bar"); final Intent intent = new Intent(); final MockLoopy loopy = Mockito.mock(MockLoopy.class); intent.setComponent(cn); MockAppDataCache.setInstance(appDataCache); Mockito.when(appDataCache.getAppLabel("foo", "bar")).thenReturn(null); Mockito.when(context.getPackageManager()).thenReturn(packageManager); Mockito.when(packageManager.getActivityInfo(cn, 0)).thenReturn(activityInfo); Mockito.when(activityInfo.loadLabel(packageManager)).thenReturn(appName); Mockito.doCallRealMethod().when(loopy).shareFromIntent(context, item, intent); loopy.shareFromIntent(context, item, intent); Mockito.verify(loopy).share(item, appName, null); }
public void testHasAndPermission() { Context trueContext = Mockito.mock(MockContext.class); Context falseContext = Mockito.mock(MockContext.class); Mockito.when(trueContext.checkCallingOrSelfPermission(Mockito.anyString())).thenReturn(PackageManager.PERMISSION_GRANTED); Mockito.when(falseContext.checkCallingOrSelfPermission(Mockito.anyString())).thenReturn(PackageManager.PERMISSION_DENIED); assertTrue(AppUtils.getInstance().hasAndPermission(trueContext, "foo", "bar")); assertFalse(AppUtils.getInstance().hasAndPermission(falseContext, "foo", "bar")); }
public void testListAppsForType() { final Intent intent = new Intent(); PackageManager pm = Mockito.mock(PackageManager.class); Context context = Mockito.mock(MockContext.class); ResolveInfo foo = Mockito.mock(ResolveInfo.class); ResolveInfo bar = Mockito.mock(ResolveInfo.class); List<ResolveInfo> infos = Arrays.asList(foo, bar); Mockito.when(foo.loadLabel(pm)).thenReturn("foo"); Mockito.when(bar.loadLabel(pm)).thenReturn("bar"); Mockito.when(context.getPackageManager()).thenReturn(pm); Mockito.when(pm.queryIntentActivities(intent, 0)).thenReturn(infos); MockAppUtils appUtils = new MockAppUtils() { @Override public Intent getSendIntent() { return intent; } }; List<ResolveInfo> apps = appUtils.listAppsForType(context, "foobar"); assertNotNull(apps); assertEquals(infos.size(), apps.size()); // Check sorted assertSame(bar, apps.get(0)); assertSame(foo, apps.get(1)); Mockito.verify(pm).queryIntentActivities(intent, 0); }
@Before public void createVolleyRequest() { context = new MockContext(); volleyRequest = new VolleyRequest(); }
@Override public Context getApplicationContext() { return new MockContext(); }
/** * <p> * Creates a new content provider of the same type as that passed to the test case class, * with an authority name set to the authority parameter, and using an SQLite database as * the underlying data source. The SQL statement parameter is used to create the database. * This method also creates a new {@link MockContentResolver} and adds the provider to it. * </p> * <p> * Both the new provider and the new resolver are put into an {@link IsolatedContext} * that uses the targetContext parameter for file operations and a {@link MockContext} * for everything else. The IsolatedContext prepends the filenamePrefix parameter to * file, database, and directory names. * </p> * <p> * This is a convenience method for creating a "mock" provider that can contain test data. * </p> * * @param targetContext The context to use as the basis of the IsolatedContext * @param filenamePrefix A string that is prepended to file, database, and directory names * @param providerClass The type of the provider being tested * @param authority The authority string to associated with the test provider * @param databaseName The name assigned to the database * @param databaseVersion The version assigned to the database * @param sql A string containing the SQL statements that are needed to create the desired * database and its tables. The format is the same as that generated by the * <a href="http://www.sqlite.org/sqlite.html">sqlite3</a> tool's <code>.dump</code> command. * @return ContentResolver A new {@link MockContentResolver} linked to the provider * * @throws IllegalAccessException * @throws InstantiationException */ public static <T extends ContentProvider> ContentResolver newResolverWithContentProviderFromSql( Context targetContext, String filenamePrefix, Class<T> providerClass, String authority, String databaseName, int databaseVersion, String sql) throws IllegalAccessException, InstantiationException { MockContentResolver resolver = new MockContentResolver(); RenamingDelegatingContext targetContextWrapper = new RenamingDelegatingContext( new MockContext(), // The context that most methods are delegated to targetContext, // The context that file methods are delegated to filenamePrefix); Context context = new IsolatedContext(resolver, targetContextWrapper); DatabaseUtils.createDbFromSqlStatements(context, databaseName, databaseVersion, sql); T provider = providerClass.newInstance(); provider.attachInfo(context, null); resolver.addProvider(authority, provider); return resolver; }
@Before public void setUp() throws Exception { context = mock(MockContext.class); digitsClient = mock(DigitsClient.class); sessionManager = mock(SessionManager.class); resultReceiver = mock(ResultReceiver.class); activityClassManager = mock(ActivityClassManager.class); callbackCaptor = ArgumentCaptor.forClass(Callback.class); loginCodeActivity = LoginCodeActivity.class; confirmationCodeActivity = ConfirmationCodeActivity.class; retrofitError = mock(RetrofitError.class); resources = mock(Resources.class); authConfig = new AuthConfig(); authConfig.isEmailEnabled = true; authConfig.isVoiceEnabled = true; authResponse = new AuthResponse(); authResponse.requestId = FAKE_REQUEST_ID; authResponse.userId = FAKE_USER_ID; authResponse.normalizedPhoneNumber = PHONE_WITH_COUNTRY_CODE; authResponse.authConfig = authConfig; deviceRegistrationResponse = new DeviceRegistrationResponse(); deviceRegistrationResponse.authConfig = authConfig; deviceRegistrationResponse.normalizedPhoneNumber = PHONE_WITH_COUNTRY_CODE; digitsEventDetailsBuilder = new DigitsEventDetailsBuilder() .withAuthStartTime(System.currentTimeMillis()); when(activityClassManager.getLoginCodeActivity()).thenReturn(loginCodeActivity); when(activityClassManager.getConfirmationActivity()).thenReturn(confirmationCodeActivity); when(context.getPackageName()).thenReturn(getClass().getPackage().toString()); when(retrofitError.isNetworkError()).thenReturn(false); when(context.getResources()).thenReturn(resources); when(resources.getString(R.string.dgts__try_again)).thenReturn("try again"); couldNotAuthenticateException = new MockDigitsApiException (new ApiError("Message", TwitterApiErrorConstants.COULD_NOT_AUTHENTICATE), null, retrofitError); userIsNotSdkUserException = new MockDigitsApiException (new ApiError("Message", TwitterApiErrorConstants.USER_IS_NOT_SDK_USER), null, retrofitError); registrationRateExceededException = new MockDigitsApiException (new ApiError("Message", TwitterApiErrorConstants.DEVICE_REGISTRATION_RATE_EXCEEDED), null, retrofitError); guestAuthException = new MockDigitsApiException (new ApiError("Message", TwitterApiConstants.Errors.GUEST_AUTH_ERROR_CODE), null, retrofitError); }
@Before public void setUp() throws Exception { digits = mock(Digits.class); digitsUserAgent = new DigitsUserAgent("digitsVersion", "androidVersion", "appName"); sessionManager = mock(SessionManager.class); twitterCore = mock(TwitterCore.class); twitterAuthConfig = new TwitterAuthConfig(TestConstants.CONSUMER_KEY, TestConstants.CONSUMER_SECRET); digitsApiClient = mock(DigitsApiClient.class); service = mock(ApiInterface.class); executorService = mock(ExecutorService.class); context = mock(MockContext.class); controller = mock(DigitsController.class); callback = mock(AuthCallback.class); digitsEventCollector = mock(DigitsEventCollector.class); fabric = mock(Fabric.class); activity = mock(Activity.class); loginResultReceiver = new LoginResultReceiver(new WeakAuthCallback(callback), sessionManager, mock(DigitsEventCollector.class)); authRequestQueue = createRequestQueue(); userSession = DigitsSession.create(TestConstants.DIGITS_USER, TestConstants.PHONE); guestSession = DigitsSession.create(TestConstants.LOGGED_OUT_USER, ""); digitsEventDetailsBuilder = new DigitsEventDetailsBuilder() .withAuthStartTime(System.currentTimeMillis()) .withCountry("US") .withLanguage("en"); detailsArgumentCaptor = ArgumentCaptor.forClass(DigitsEventDetails.class); when(digitsApiClient.getService()).thenReturn(service); when(digits.getContext()).thenReturn(context); when(digits.getAuthConfig()).thenReturn(twitterAuthConfig); when(twitterCore.getSSLSocketFactory()).thenReturn(mock(SSLSocketFactory.class)); when(digits.getExecutorService()).thenReturn(mock(ExecutorService.class)); when(digits.getActivityClassManager()).thenReturn(new ActivityClassManagerImp()); when(digits.getDigitsEventCollector()).thenReturn(digitsEventCollector); when(digits.getFabric()).thenReturn(fabric); when(digits.getVersion()).thenReturn(ANY_VERSION); when(fabric.getCurrentActivity()).thenReturn(activity); when(context.getPackageName()).thenReturn(getClass().getPackage().toString()); when(activity.getPackageName()).thenReturn(getClass().getPackage().toString()); when(activity.isFinishing()).thenReturn(false); when(controller.getErrors()).thenReturn(mock(ErrorCodes.class)); apiClientManager = mock(DigitsApiClientManager.class); when(apiClientManager.getService()).thenReturn(service); when(apiClientManager.getApiClient()).thenReturn(digitsApiClient); digitsClient = new DigitsClient(digits, sessionManager, apiClientManager, authRequestQueue, digitsEventCollector, sandboxConfig) { @Override LoginResultReceiver createResultReceiver(AuthCallback callback) { return loginResultReceiver; } }; }