return Task.forResult(appLinkResults);
@Override public Task<ParseSQLiteDatabase> then(Task<Void> task) { return Task.forResult(db); } });
@Override public Task<Boolean> matchesAsync(T object, ParseSQLiteDatabase db) { try { Object value = getValue(object, key); return Task.forResult(matchesStatelessConstraint(operator, constraint, value, allKeyConstraints)); } catch (ParseException e) { return Task.forError(e); } } };
@Override public Task<Boolean> matchesAsync(T object, ParseSQLiteDatabase db) { Object objectValue; try { objectValue = getValue(object, key); } catch (ParseException e) { return Task.forError(e); } return Task.forResult(matchesEqualConstraint(queryConstraintValue, objectValue)); } });
@Override public <T extends ParseObject> Task<Integer> countAsync( ParseQuery.State<T> state, ParseUser user, Task<Void> cancellationToken) { countCalled.set(true); return Task.forResult(null); }
@Override public Task<Void> setIfNeededAsync(ParseUser user) { synchronized (mutex) { if (!user.isCurrentUser() || currentUserMatchesDisk) { return Task.forResult(null); } } return setAsync(user); }
@Override public Task<Boolean> then(Task<Integer> task) { boolean exists = task.getResult() == 1; if (exists) { return Task.forResult(true); } return legacy.existsAsync(); } });
static Task<Void> revokeAsync(String sessionToken) { if (sessionToken == null || !isRevocableSessionToken(sessionToken)) { return Task.forResult(null); } return getSessionController().revokeAsync(sessionToken); }
private ParseCurrentConfigController mockParseCurrentConfigController() { ParseCurrentConfigController currentConfigController = mock(ParseCurrentConfigController.class); when(currentConfigController.setCurrentConfigAsync(any(ParseConfig.class))) .thenReturn(Task.<Void>forResult(null)); return currentConfigController; }
private <T> ParseCloudCodeController mockParseCloudCodeControllerWithResponse(final T result) { ParseCloudCodeController controller = mock(ParseCloudCodeController.class); when(controller.callFunctionInBackground(anyString(), anyMap(), anyString())) .thenReturn(Task.forResult(result)); return controller; } }
/* package */ Task<Void> synchronizeAuthDataAsync(String authType) { Map<String, String> authData; synchronized (mutex) { if (!isCurrentUser()) { return Task.forResult(null); } authData = getAuthData(authType); } return synchronizeAuthDataAsync(getAuthenticationManager(), authType, authData); }
static Task<String> upgradeToRevocableSessionAsync(String sessionToken) { if (sessionToken == null || isRevocableSessionToken(sessionToken)) { return Task.forResult(sessionToken); } return getSessionController().upgradeToRevocable(sessionToken).onSuccess(new Continuation<ParseObject.State, String>() { @Override public String then(Task<ParseObject.State> task) { ParseObject.State result = task.getResult(); return ParseObject.<ParseSession>from(result).getSessionToken(); } }); }
@Test public void testRegister() { ParseUser user = mock(ParseUser.class); when(controller.getAsync(false)).thenReturn(Task.forResult(user)); manager.register("test_provider", provider); verify(controller).getAsync(false); verify(user).synchronizeAuthDataAsync("test_provider"); }
@Test public void testSubscribeInBackgroundSuccess() throws Exception { ParsePushChannelsController controller = mock(ParsePushChannelsController.class); when(controller.subscribeInBackground(anyString())).thenReturn(Task.<Void>forResult(null)); ParseCorePlugins.getInstance().registerPushChannelsController(controller); ParseTaskUtils.wait(ParsePush.subscribeInBackground("test")); verify(controller, times(1)).subscribeInBackground("test"); }
@Test public void testUnsubscribeInBackgroundSuccess() throws Exception { ParsePushChannelsController controller = mock(ParsePushChannelsController.class); when(controller.unsubscribeInBackground(anyString())).thenReturn(Task.<Void>forResult(null)); ParseCorePlugins.getInstance().registerPushChannelsController(controller); ParseTaskUtils.wait(ParsePush.unsubscribeInBackground("test")); verify(controller, times(1)).unsubscribeInBackground("test"); }
@Test public void testRegisterMultipleShouldThrow() { when(controller.getAsync(false)).thenReturn(Task.<ParseUser>forResult(null)); AuthenticationCallback provider2 = mock(AuthenticationCallback.class); manager.register("test_provider", provider); thrown.expect(IllegalStateException.class); manager.register("test_provider", provider2); }
@Test public void testExistAsyncFromStore() throws Exception { //noinspection unchecked ParseObjectStore<ParseInstallation> store = mock(ParseObjectStore.class); when(store.existsAsync()).thenReturn(Task.forResult(true)); // Create test controller CachedCurrentInstallationController controller = new CachedCurrentInstallationController(store, null); assertTrue(ParseTaskUtils.wait(controller.existsAsync())); verify(store, times(1)).existsAsync(); }
@Test public void testGetCurrentInstallation() { // Mock currentInstallationController to make setAsync work ParseCurrentInstallationController controller = mock(ParseCurrentInstallationController.class); ParseInstallation currentInstallation = new ParseInstallation(); when(controller.getAsync()).thenReturn(Task.forResult(currentInstallation)); ParseCorePlugins.getInstance().registerCurrentInstallationController(controller); ParseInstallation installation = ParseInstallation.getCurrentInstallation(); assertEquals(currentInstallation, installation); verify(controller, times(1)).getAsync(); }
@Test public void testExistsAsyncWithInDiskCurrentUserSet() throws Exception { ParseObjectStore<ParseUser> store = (ParseObjectStore<ParseUser>) mock(ParseObjectStore.class); when(store.existsAsync()).thenReturn(Task.forResult(true)); CachedCurrentUserController controller = new CachedCurrentUserController(store); assertTrue(ParseTaskUtils.wait(controller.existsAsync())); }
@Test public void testExistsAsyncWithNoInMemoryAndInDiskCurrentUserSet() throws Exception { ParseObjectStore<ParseUser> store = (ParseObjectStore<ParseUser>) mock(ParseObjectStore.class); when(store.existsAsync()).thenReturn(Task.forResult(false)); CachedCurrentUserController controller = new CachedCurrentUserController(store); assertFalse(ParseTaskUtils.wait(controller.existsAsync())); }