/* package for tests */ Task<Void> cleanUpAuthDataAsync() { ParseAuthenticationManager controller = getAuthenticationManager(); Map<String, Map<String, String>> authData; synchronized (mutex) { authData = getState().authData(); if (authData.size() == 0) { return Task.forResult(null); // Nothing to see or do here... } } List<Task<Void>> tasks = new ArrayList<>(); Iterator<Map.Entry<String, Map<String, String>>> i = authData.entrySet().iterator(); while (i.hasNext()) { Map.Entry<String, Map<String, String>> entry = i.next(); if (entry.getValue() == null) { i.remove(); tasks.add(controller.restoreAuthenticationAsync(entry.getKey(), null).makeVoid()); } } State newState = getState().newBuilder() .authData(authData) .build(); setState(newState); return Task.whenAll(tasks); }
/* package */ Task<Void> logOutAsync(boolean revoke) { ParseAuthenticationManager controller = getAuthenticationManager(); List<Task<Void>> tasks = new ArrayList<>(); final String oldSessionToken; synchronized (mutex) { oldSessionToken = getState().sessionToken(); for (Map.Entry<String, Map<String, String>> entry : getAuthData().entrySet()) { tasks.add(controller.deauthenticateAsync(entry.getKey())); } State newState = getState().newBuilder() .sessionToken(null) .isNew(false) .build(); isCurrentUser = false; setState(newState); } if (revoke) { tasks.add(ParseSession.revokeAsync(oldSessionToken)); } return Task.whenAll(tasks); }
@Test public void testGetAsyncLazyAnonymousUser() throws Exception { ParseUser.State state = new ParseUser.State.Builder() .putAuthData(ParseAnonymousUtils.AUTH_TYPE, new HashMap<String, String>()) .build(); ParseObjectStore<ParseUser> store = (ParseObjectStore<ParseUser>) mock(ParseObjectStore.class); when(store.getAsync()).thenReturn(Task.forResult(ParseObject.<ParseUser>from(state))); CachedCurrentUserController controller = new CachedCurrentUserController(store); ParseUser user = ParseTaskUtils.wait(controller.getAsync(false)); assertTrue(user.isLazy()); }
@Test public void testSetAsyncWithNoInMemoryCurrentUser() throws Exception { ParseUser.State state = new ParseUser.State.Builder() .put("key", "value") .build(); ParseUser currentUser = ParseObject.from(state); ParseObjectStore<ParseUser> store = (ParseObjectStore<ParseUser>) mock(ParseObjectStore.class); when(store.setAsync(currentUser)).thenReturn(Task.<Void>forResult(null)); CachedCurrentUserController controller = new CachedCurrentUserController(store); ParseTaskUtils.wait(controller.setAsync(currentUser)); // Verify it was persisted verify(store, times(1)).setAsync(currentUser); // TODO(mengyan): Find a way to verify user.synchronizeAllAuthData() is called // Verify newUser is currentUser assertTrue(currentUser.isCurrentUser()); // Make sure in memory currentUser is up to date assertSame(currentUser, controller.currentUser); assertTrue(controller.currentUserMatchesDisk); }
@Test public void testGetAsyncWithCurrentUserReadFromDiskSuccess() throws Exception { ParseUser.State state = new ParseUser.State.Builder() .put("key", "value") .build(); ParseUser currentUserInDisk = ParseObject.from(state); ParseObjectStore<ParseUser> store = (ParseObjectStore<ParseUser>) mock(ParseObjectStore.class); when(store.getAsync()).thenReturn(Task.forResult(currentUserInDisk)); CachedCurrentUserController controller = new CachedCurrentUserController(store); ParseUser currentUser = ParseTaskUtils.wait(controller.getAsync(false)); assertSame(currentUser, currentUserInDisk); assertSame(currentUser, controller.currentUser); assertTrue(controller.currentUserMatchesDisk); assertTrue(currentUser.isCurrentUser()); assertEquals("value", currentUser.get("key")); }
@Test public void testLoginAsyncWithUserStateCreated() throws Exception { // Make mock response and client JSONObject mockResponse = generateBasicMockResponse(); ParseHttpClient restClient = ParseTestUtils.mockParseHttpClientWithResponse(mockResponse, 201, "OK"); // Make test user state and operationSet ParseUser.State state = new ParseUser.State.Builder() .put("username", "testUserName") .put("password", "testPassword") .build(); ParseOperationSet operationSet = new ParseOperationSet(); operationSet.put("username", new ParseSetOperation("testUserName")); operationSet.put("password", new ParseSetOperation("testPassword")); NetworkUserController controller = new NetworkUserController(restClient, true); ParseUser.State newState = ParseTaskUtils.wait(controller.logInAsync(state, operationSet)); // Verify user state verifyBasicUserState(mockResponse, newState); assertTrue(newState.isNew()); assertFalse(newState.isComplete()); }
@Test public void testSignUpAsync() throws Exception { // Make mock response and client JSONObject mockResponse = generateBasicMockResponse(); ParseHttpClient restClient = ParseTestUtils.mockParseHttpClientWithResponse(generateBasicMockResponse(), 200, "OK"); // Make test user state and operationSet ParseUser.State state = new ParseUser.State.Builder() .put("username", "testUserName") .put("password", "testPassword") .build(); ParseOperationSet operationSet = new ParseOperationSet(); operationSet.put("username", new ParseSetOperation("testUserName")); operationSet.put("password", new ParseSetOperation("testPassword")); NetworkUserController controller = new NetworkUserController(restClient, true); ParseUser.State newState = ParseTaskUtils.wait( controller.signUpAsync(state, operationSet, "sessionToken")); verifyBasicUserState(mockResponse, newState); assertFalse(newState.isComplete()); assertTrue(newState.isNew()); }
@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 testEncodeDecodeWithNullValues() { ParseUser.State state = new ParseUser.State.Builder() .sessionToken(null) .authData(null) .build(); ParseUserCurrentCoder coder = ParseUserCurrentCoder.get(); JSONObject object = coder.encode(state, null, PointerEncoder.get()); ParseUser.State.Builder builder = coder.decode(new ParseUser.State.Builder(), object, ParseDecoder.get()); state = builder.build(); assertNull(state.sessionToken()); assertEquals(0, state.authData().size()); } }
@Test public void testSignUpAsyncWithObjectIdSetAndAuthDataNotSet() throws Exception { // Register a mock currentUserController to make getCurrentUser work ParseCurrentUserController currentUserController = mock(ParseCurrentUserController.class); when(currentUserController.getAsync(anyBoolean())).thenReturn(Task.<ParseUser>forResult(null)); ParseCorePlugins.getInstance().registerCurrentUserController(currentUserController); ParseUser.State userState = new ParseUser.State.Builder() .objectId("test") .build(); ParseUser user = ParseObject.from(userState); user.setUsername("userName"); user.setPassword("password"); thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Cannot sign up a user that has already signed up."); ParseTaskUtils.wait(user.signUpAsync(Task.<Void>forResult(null))); }
@Test public void testParcelableState() { ParseUser.State state = new ParseUser.State.Builder() .objectId("test") .isNew(true) .build(); ParseUser user = ParseObject.from(state); assertTrue(user.isNew()); Parcel parcel = Parcel.obtain(); user.writeToParcel(parcel, 0); parcel.setDataPosition(0); user = (ParseUser) ParseObject.CREATOR.createFromParcel(parcel); assertTrue(user.isNew()); }
@Test public void testGetAsyncAnonymousUser() throws Exception { ParseUser.State state = new ParseUser.State.Builder() .objectId("fake") .putAuthData(ParseAnonymousUtils.AUTH_TYPE, new HashMap<String, String>()) .build(); ParseObjectStore<ParseUser> store = (ParseObjectStore<ParseUser>) mock(ParseObjectStore.class); when(store.getAsync()).thenReturn(Task.forResult(ParseObject.<ParseUser>from(state))); CachedCurrentUserController controller = new CachedCurrentUserController(store); ParseUser user = ParseTaskUtils.wait(controller.getAsync(false)); assertFalse(user.isLazy()); }
@Override public ParseUser.State then(Task<JSONObject> task) { JSONObject result = task.getResult(); // TODO(grantland): Does the server really respond back with complete object data if the // object isn't new? boolean isNew = command.getStatusCode() == STATUS_CODE_CREATED; boolean isComplete = !isNew; return coder.decode(new ParseUser.State.Builder(), result, ParseDecoder.get()) .isComplete(isComplete) .isNew(isNew) .build(); } });
@Test public void testDecodeSuccessWithoutSessionTokenAndAuthData() { JSONObject objectJson = new JSONObject(); ParseUserCurrentCoder coder = ParseUserCurrentCoder.get(); ParseUser.State.Builder builder = coder.decode(new ParseUser.State.Builder(), objectJson, ParseDecoder.get()); // We use the builder to build a state to verify the content in the builder ParseUser.State state = builder.build(); assertNull(state.sessionToken()); // We always return non-null for authData() assertEquals(0, state.authData().size()); }
@Override public ParseUser.State then(Task<JSONObject> task) { JSONObject result = task.getResult(); return coder.decode(new ParseUser.State.Builder(), result, ParseDecoder.get()) .isComplete(true) .build(); } });
@Override public ParseUser.State then(Task<JSONObject> task) { JSONObject result = task.getResult(); return coder.decode(new ParseUser.State.Builder(), result, ParseDecoder.get()) .isComplete(false) .isNew(true) .build(); } });
private Task<Void> setSessionTokenInBackground(String newSessionToken) { synchronized (mutex) { State state = getState(); if (newSessionToken.equals(state.sessionToken())) { return Task.forResult(null); } State.Builder builder = state.newBuilder() .sessionToken(newSessionToken); setState(builder.build()); return saveCurrentUserAsync(this); } }
@Override public ParseUser.State then(Task<JSONObject> task) { JSONObject result = task.getResult(); return coder.decode(new ParseUser.State.Builder(), result, ParseDecoder.get()) .isComplete(true) .build(); } });
@Test public void testEncodeSuccessWithEmptyState() { ParseUser.State state = new ParseUser.State.Builder() .build(); ParseUserCurrentCoder coder = ParseUserCurrentCoder.get(); JSONObject objectJson = coder.encode(state, null, PointerEncoder.get()); assertFalse(objectJson.has(KEY_SESSION_TOKEN)); assertFalse(objectJson.has(KEY_AUTH_DATA)); }
@Override public ParseUser.State then(Task<JSONObject> task) { JSONObject result = task.getResult(); return coder.decode(new ParseUser.State.Builder(), result, ParseDecoder.get()) .isComplete(true) .isNew(command.getStatusCode() == STATUS_CODE_CREATED) .putAuthData(authType, authData) .build(); } });