@Test public void testGetAsync() throws Exception { File file = new File(temporaryFolder.getRoot(), "test"); JSONObject json = new JSONObject(); ParseFileUtils.writeJSONObjectToFile(file, json); ParseUser.State.Builder builder = new ParseUser.State.Builder(); builder.put("foo", "bar"); ParseUserCurrentCoder coder = mock(ParseUserCurrentCoder.class); when(coder.decode(any(ParseUser.State.Builder.class), any(JSONObject.class), any(ParseDecoder.class))) .thenReturn(builder); FileObjectStore<ParseUser> store = new FileObjectStore<>(ParseUser.class, file, coder); ParseUser user = ParseTaskUtils.wait(store.getAsync()); assertEquals("bar", user.getState().get("foo")); }
.put("newKey", "newValue") .sessionToken("newSessionToken") .build();
.put("key", "value") .sessionToken("sessionToken") .build();
.put("newKey", "newValue") .sessionToken("newSessionToken") .isNew(false)
ParseUser.State sessionTokenState = new ParseUser.State.Builder() .sessionToken("sessionToken") .put("key0", "value0") .put("key1", "value1") .isComplete(true) .build(); ParseUser.State newState = new ParseUser.State.Builder() .put("key0", "newValue0") .put("key2", "value2") .isComplete(true) .build();
ParseUser.State newUserState = new ParseUser.State.Builder() .objectId("objectId") .put("newKey", "newValue") .sessionToken("newSessionToken") .isNew(true)
@Test public void testLoginWithAsyncWithNoCurrentUser() throws Exception { // 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(), Matchers.<Map<String, String>>any())) .thenReturn(Task.forResult(newUserState)); ParseCorePlugins.getInstance().registerUserController(userController); // Register a mock currentUserController to make getCurrentUser work ParseCurrentUserController currentUserController = mock(ParseCurrentUserController.class); when(currentUserController.getAsync(false)).thenReturn(Task.<ParseUser>forResult(null)); when(currentUserController.setAsync(any(ParseUser.class))) .thenReturn(Task.<Void>forResult(null)); 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 login authData verify(userController, times(1)).logInAsync("facebook", authData); // Make sure we save the new created user as currentUser verify(currentUserController, times(1)).setAsync(any(ParseUser.class)); // Make sure the new created user has correct data assertEquals("newValue", userAfterLogin.get("newKey")); assertEquals("newSessionToken", userAfterLogin.getSessionToken()); }
@Test public void testSetStateDoesNotAddNonExistentAuthData() { // Set user initial state ParseUser.State userState = new ParseUser.State.Builder() .objectId("test") .put("oldKey", "oldValue") .put("key", "value") .build(); ParseUser user = ParseObject.from(userState); user.setIsCurrentUser(true); // Build new state ParseUser.State newUserState = new ParseUser.State.Builder() .objectId("testAgain") .put("key", "valueAgain") .build(); user.setState(newUserState); // Make sure we do not add authData when it did not exist before assertFalse(user.keySet().contains("authData")); assertEquals(1, user.keySet().size()); assertEquals(0, user.getAuthData().size()); // Make sure old state is replaced assertFalse(user.has("oldKey")); // Make sure new state is set assertEquals("testAgain", user.getObjectId()); assertEquals("valueAgain", user.get("key")); }
@Test public void testSetCurrentUserStateWithoutAuthData() { // 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") .put("oldKey", "oldValue") .put("key", "value") .putAuthData(authType, authData) .build(); ParseUser user = ParseObject.from(userState); user.setIsCurrentUser(true); // Build new state ParseUser.State newUserState = new ParseUser.State.Builder() .objectId("testAgain") .put("key", "valueAgain") .build(); user.setState(newUserState); // Make sure we keep the authData assertEquals(1, user.getAuthData().size()); assertEquals(authData, user.getAuthData().get(authType)); // Make sure old state is replaced assertFalse(user.has("oldKey")); // Make sure new state is set assertEquals("testAgain", user.getObjectId()); assertEquals("valueAgain", user.get("key")); }
@Test public void testSetAsyncWithOldInMemoryCurrentUser() throws Exception { // Mock currentUser in memory ParseUser oldCurrentUser = mock(ParseUser.class); when(oldCurrentUser.logOutAsync(anyBoolean())).thenReturn(Task.<Void>forResult(null)); 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); controller.currentUser = oldCurrentUser; ParseTaskUtils.wait(controller.setAsync(currentUser)); // Make sure oldCurrentUser logout verify(oldCurrentUser, times(1)).logOutAsync(false); // 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 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")); }
@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 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 testLoginAsyncWithUserStateNotCreated() throws Exception { // Make mock response and client JSONObject mockResponse = generateBasicMockResponse(); ParseHttpClient restClient = ParseTestUtils.mockParseHttpClientWithResponse(mockResponse, 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.logInAsync(state, operationSet)); // Verify user state verifyBasicUserState(mockResponse, newState); assertFalse(newState.isNew()); assertTrue(newState.isComplete()); }
@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()); }
@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")); }
@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); }
public Builder sessionToken(String sessionToken) { return put(KEY_SESSION_TOKEN, sessionToken); }
public Builder authData(Map<String, Map<String, String>> authData) { return put(KEY_AUTH_DATA, authData); }