@Override public <T extends ParseObject> Task<Integer> countAsync( ParseQuery.State<T> state, ParseUser user, Task<Void> cancellationToken) { String sessionToken = user != null ? user.getSessionToken() : null; return countAsync(state, sessionToken, cancellationToken); }
@Override public <T extends ParseObject> Task<List<T>> findAsync( ParseQuery.State<T> state, ParseUser user, Task<Void> cancellationToken) { String sessionToken = user != null ? user.getSessionToken() : null; return findAsync(state, sessionToken, cancellationToken); }
@Override public String then(Task<ParseUser> task) { ParseUser user = task.getResult(); return user != null ? user.getSessionToken() : null; } });
public static String getCurrentSessionToken() { ParseUser current = ParseUser.getCurrentUser(); return current != null ? current.getSessionToken() : null; }
/** * Links this user to a third party authentication source. * <p/> * <strong>Note:</strong> This shouldn't be called directly unless developing a third party authentication * library. * * @param authType The name of the third party authentication source. * @param authData The user credentials of the third party authentication source. * @return A {@code Task} is resolved when linking completes. * @see AuthenticationCallback */ public Task<Void> linkWithInBackground( String authType, Map<String, String> authData) { if (authType == null) { throw new IllegalArgumentException("Invalid authType: " + null); } return linkWithAsync(authType, authData, getSessionToken()); }
private Task<Void> upgradeToRevocableSessionAsync(Task<Void> toAwait) { final String sessionToken = getSessionToken(); return toAwait.continueWithTask(new Continuation<Void, Task<String>>() { @Override public Task<String> then(Task<Void> task) { return ParseSession.upgradeToRevocableSessionAsync(sessionToken); } }).onSuccessTask(new Continuation<String, Task<Void>>() { @Override public Task<Void> then(Task<String> task) { String result = task.getResult(); return setSessionTokenInBackground(result); } }); }
@Override public <T extends ParseObject> Task<Integer> countAsync( final ParseQuery.State<T> state, final ParseUser user, final Task<Void> cancellationToken) { final String sessionToken = user != null ? user.getSessionToken() : null; CommandDelegate<Integer> callbacks = new CommandDelegate<Integer>() { @Override public Task<Integer> runOnNetworkAsync() { return networkController.countAsync(state, sessionToken, cancellationToken); } @Override public Task<Integer> runFromCacheAsync() { return countFromCacheAsync(state, sessionToken); } }; return runCommandWithPolicyAsync(callbacks, state.cachePolicy()); }
@Override public <T extends ParseObject> Task<List<T>> findAsync( final ParseQuery.State<T> state, final ParseUser user, final Task<Void> cancellationToken) { final String sessionToken = user != null ? user.getSessionToken() : null; CommandDelegate<List<T>> callbacks = new CommandDelegate<List<T>>() { @Override public Task<List<T>> runOnNetworkAsync() { return networkController.findAsync(state, sessionToken, cancellationToken); } @Override public Task<List<T>> runFromCacheAsync() { return findFromCacheAsync(state, sessionToken); } }; return runCommandWithPolicyAsync(callbacks, state.cachePolicy()); }
@Override /* package */ void setState(ParseObject.State newState) { if (isCurrentUser()) { State.Builder newStateBuilder = newState.newBuilder(); // Avoid clearing sessionToken when updating the current user's State via ParseQuery result if (getSessionToken() != null && newState.get(KEY_SESSION_TOKEN) == null) { newStateBuilder.put(KEY_SESSION_TOKEN, getSessionToken()); } // Avoid clearing authData when updating the current user's State via ParseQuery result if (getAuthData().size() > 0 && newState.get(KEY_AUTH_DATA) == null) { newStateBuilder.put(KEY_AUTH_DATA, getAuthData()); } newState = newStateBuilder.build(); } super.setState(newState); }
@Test public void testGetCurrentSessionTokenAsyncWithCurrentUserSet() throws Exception { CachedCurrentUserController controller = new CachedCurrentUserController(null); // We set the currentUser to make sure getAsync() return a mock user ParseUser currentUser = mock(ParseUser.class); when(currentUser.getSessionToken()).thenReturn("sessionToken"); controller.currentUser = currentUser; String sessionToken = ParseTaskUtils.wait(controller.getCurrentSessionTokenAsync()); assertEquals("sessionToken", sessionToken); }
@Override public void done(ParseUser user, ParseException e) { done.release(); assertNull(e); // Make sure user's data is correct assertEquals("sessionToken", user.getSessionToken()); assertEquals("value", user.get("key")); } });
@Override public void done(ParseUser user, ParseException e) { done.release(); assertNull(e); // Make sure user's data is correct assertEquals("newSessionToken", user.getSessionToken()); assertEquals("newValue", user.get("newKey")); } });
@Test public void testLoginWithAsyncWithLinkedLazyUser() throws Exception { // Register a mock currentUserController to make getCurrentUser work ParseUser currentUser = new ParseUser(); currentUser.putAuthData(ParseAnonymousUtils.AUTH_TYPE, new HashMap<String, String>()); setLazy(currentUser); ParseUser partialMockCurrentUser = spy(currentUser); when(partialMockCurrentUser.getSessionToken()).thenReturn("oldSessionToken"); doReturn(Task.<ParseUser>forResult(null)) .when(partialMockCurrentUser) .resolveLazinessAsync(Matchers.<Task<Void>>any()); ParseCurrentUserController currentUserController = mock(ParseCurrentUserController.class); when(currentUserController.getAsync(false)).thenReturn(Task.forResult(partialMockCurrentUser)); ParseCorePlugins.getInstance().registerCurrentUserController(currentUserController); String authType = "facebook"; Map<String, String> authData = new HashMap<>(); authData.put("token", "123"); ParseUser userAfterLogin = ParseTaskUtils.wait(ParseUser.logInWithInBackground(authType, authData)); // Make sure we stripAnonymity assertNull(userAfterLogin.getAuthData().get(ParseAnonymousUtils.AUTH_TYPE)); // Make sure we update authData assertEquals(authData, userAfterLogin.getAuthData().get("facebook")); // Make sure we resolveLaziness verify(partialMockCurrentUser, times(1)).resolveLazinessAsync(Matchers.<Task<Void>>any()); }
@Test public void testUnlinkFromAsyncWithAuthType() throws Exception { // Register a mock currentUserController to make getAsync work ParseUser mockUser = mock(ParseUser.class); when(mockUser.getSessionToken()).thenReturn("sessionToken"); ParseCurrentUserController currentUserController = mock(ParseCurrentUserController.class); when(currentUserController.getAsync()).thenReturn(Task.forResult(mockUser)); ParseCorePlugins.getInstance().registerCurrentUserController(currentUserController); // Set user initial state String authType = "facebook"; Map<String, String> authData = new HashMap<>(); authData.put("facebookToken", "facebookTest"); ParseUser.State userState = new ParseUser.State.Builder() .objectId("test") .putAuthData(authType, authData) .build(); ParseUser user = ParseObject.from(userState); ParseUser partialMockUser = spy(user); doReturn(Task.<Void>forResult(null)) .when(partialMockUser) .saveAsync(anyString(), Matchers.<Task<Void>>any()); ParseTaskUtils.wait(partialMockUser.unlinkFromInBackground(authType)); // Verify we delete authData assertNull(user.getAuthData().get("facebook")); // Verify we save the user verify(partialMockUser, times(1)).saveAsync(eq("sessionToken"), Matchers.<Task<Void>>any()); }
/** * Removes the previously cached result for this query, forcing the next find() to hit the * network. If there is no cached result for this query, then this is a no-op. */ //TODO (grantland): should be done Async since it does disk i/o & calls through to current user public void clearCachedResult() { throwIfLDSEnabled(); // TODO(grantland): Is there a more efficient way to accomplish this rather than building a // new state just to check it's cacheKey? State<T> state = builder.build(); ParseUser user = null; try { user = ParseTaskUtils.wait(getUserAsync(state)); } catch (ParseException e) { // do nothing } String sessionToken = user != null ? user.getSessionToken() : null; // TODO: Once the count queries are cached, handle the cached results of the count query. ParseKeyValueCache.clearFromKeyValueCache( ParseRESTQueryCommand.findCommand(state, sessionToken).getCacheKey() ); }
@Test public void testSignUpAsyncWithObjectIdSetAndAuthDataSet() throws Exception { // Register a mock currentUserController to make getCurrentUser work ParseUser currentUser = mock(ParseUser.class); when(currentUser.getSessionToken()).thenReturn("sessionToken"); ParseCurrentUserController currentUserController = mock(ParseCurrentUserController.class); when(currentUserController.getAsync(anyBoolean())).thenReturn(Task.forResult(currentUser)); ParseCorePlugins.getInstance().registerCurrentUserController(currentUserController); ParseUser.State userState = new ParseUser.State.Builder() .objectId("test") .putAuthData(ParseAnonymousUtils.AUTH_TYPE, null) .build(); ParseUser user = ParseObject.from(userState); user.setUsername("userName"); user.setPassword("password"); //TODO (mengyan): Avoid using partial mock after we have ParseObjectInstanceController ParseUser partialMockUser = spy(user); doReturn(Task.<Void>forResult(null)) .when(partialMockUser) .saveAsync(anyString(), Matchers.<Task<Void>>any()); ParseTaskUtils.wait(partialMockUser.signUpAsync(Task.<Void>forResult(null))); // Verify user is saved verify(partialMockUser, times(1)).saveAsync(eq("sessionToken"), Matchers.<Task<Void>>any()); }
@Test public void testLogIn() throws Exception { // Register a mock currentUserController to make setCurrentUser work ParseCurrentUserController currentUserController = mock(ParseCurrentUserController.class); when(currentUserController.setAsync(any(ParseUser.class))) .thenReturn(Task.<Void>forResult(null)); ParseCorePlugins.getInstance().registerCurrentUserController(currentUserController); // Register a mock userController to make logIn work ParseUserController userController = mock(ParseUserController.class); ParseUser.State newUserState = new ParseUser.State.Builder() .put("newKey", "newValue") .sessionToken("newSessionToken") .build(); when(userController.logInAsync(anyString(), anyString())) .thenReturn(Task.forResult(newUserState)); ParseCorePlugins.getInstance().registerUserController(userController); ParseUser user = ParseUser.logIn("userName", "password"); // Make sure user is login verify(userController, times(1)).logInAsync("userName", "password"); // Make sure we set currentUser verify(currentUserController, times(1)).setAsync(user); // Make sure user's data is correct assertEquals("newSessionToken", user.getSessionToken()); assertEquals("newValue", user.get("newKey")); }
/** * Returns whether or not this query has a cached result. */ //TODO (grantland): should be done Async since it does disk i/o & calls through to current user public boolean hasCachedResult() { throwIfLDSEnabled(); // TODO(grantland): Is there a more efficient way to accomplish this rather than building a // new state just to check it's cacheKey? State<T> state = builder.build(); ParseUser user = null; try { user = ParseTaskUtils.wait(getUserAsync(state)); } catch (ParseException e) { // do nothing } String sessionToken = user != null ? user.getSessionToken() : null; /* * TODO: Once the count queries are cached, only return false when both queries miss in the * cache. */ String raw = ParseKeyValueCache.loadFromKeyValueCache( ParseRESTQueryCommand.findCommand(state, sessionToken).getCacheKey(), state.maxCacheAge() ); return raw != null; }
@Test public void testBecome() throws Exception { // Register a mock currentUserController to make setCurrentUser work ParseCurrentUserController currentUserController = mock(ParseCurrentUserController.class); when(currentUserController.setAsync(any(ParseUser.class))) .thenReturn(Task.<Void>forResult(null)); ParseCorePlugins.getInstance().registerCurrentUserController(currentUserController); // Register a mock userController to make getUsreAsync work ParseUserController userController = mock(ParseUserController.class); ParseUser.State newUserState = new ParseUser.State.Builder() .put("key", "value") .sessionToken("sessionToken") .build(); when(userController.getUserAsync(anyString())) .thenReturn(Task.forResult(newUserState)); ParseCorePlugins.getInstance().registerUserController(userController); ParseUser user = ParseUser.become("sessionToken"); // Make sure we call getUserAsync verify(userController, times(1)).getUserAsync("sessionToken"); // Make sure we set currentUser verify(currentUserController, times(1)).setAsync(user); // Make sure user's data is correct assertEquals("sessionToken", user.getSessionToken()); assertEquals("value", user.get("key")); }
@Test public void testUpgradeToRevocableSessionAsync() throws Exception { // Register a mock currentUserController to verify setAsync ParseCurrentUserController currentUserController = mock(ParseCurrentUserController.class); ParseCorePlugins.getInstance().registerCurrentUserController(currentUserController); // Register a mock sessionController to verify revokeAsync() NetworkSessionController sessionController = mock(NetworkSessionController.class); ParseSession.State state = new ParseSession.State.Builder("_Session") .put("sessionToken", "r:newSessionToken") .build(); when(sessionController.upgradeToRevocable(anyString())) .thenReturn(Task.forResult(state)); ParseCorePlugins.getInstance().registerSessionController(sessionController); // Set user initial state ParseUser.State userState = new ParseUser.State.Builder() .objectId("test") .sessionToken("oldSessionToken") .build(); ParseUser user = ParseObject.from(userState); ParseTaskUtils.wait(user.upgradeToRevocableSessionAsync()); // Make sure we update to new sessionToken assertEquals("r:newSessionToken", user.getSessionToken()); // Make sure we update currentUser verify(currentUserController, times(1)).setAsync(user); }