@Override public String then(Task<ParseObject.State> task) { ParseObject.State result = task.getResult(); return ParseObject.<ParseSession>from(result).getSessionToken(); } });
@Override public Task<ParseUser> then(Task<State> task) { State result = task.getResult(); final ParseUser user = ParseObject.from(result); return saveCurrentUserAsync(user).onSuccess(new Continuation<Void, ParseUser>() { @Override public ParseUser then(Task<Void> task) { return user; } }); } });
@Override public Task<ParseUser> then(Task<State> task) { State result = task.getResult(); final ParseUser newCurrent = ParseObject.from(result); return saveCurrentUserAsync(newCurrent).onSuccess(new Continuation<Void, ParseUser>() { @Override public ParseUser then(Task<Void> task) { return newCurrent; } }); } });
@Test public void testGetAvailableIfKeyAvailable() { ParseObject.State state = mock(ParseObject.State.class); when(state.className()).thenReturn("TestObject"); when(state.isComplete()).thenReturn(false); when(state.availableKeys()).thenReturn(new HashSet<>(Collections.singletonList("foo"))); ParseObject object = ParseObject.from(state); object.get("foo"); }
@Test(expected = IllegalStateException.class) public void testGetUnavailable() { ParseObject.State state = mock(ParseObject.State.class); when(state.className()).thenReturn("TestObject"); when(state.isComplete()).thenReturn(false); ParseObject object = ParseObject.from(state); object.get("foo"); }
/** * Retrieves a {@code ParseObject} from a file on disk in /2/ format. * * @param coder Current coder to decode the ParseObject. * @param file The file to retrieve the object from. * @param builder An empty builder which is used to generate a empty state and rebuild a ParseObject. * @return The {@code ParseObject} that was retrieved. If the file wasn't found, or the contents * of the file is an invalid {@code ParseObject}, returns {@code null}. * @see #saveToDisk(ParseObjectCurrentCoder, ParseObject, File) */ private static <T extends ParseObject> T getFromDisk( ParseObjectCurrentCoder coder, File file, ParseObject.State.Init builder) { JSONObject json; try { json = ParseFileUtils.readFileToJSONObject(file); } catch (IOException | JSONException e) { return null; } ParseObject.State newState = coder.decode(builder, json, ParseDecoder.get()) .isComplete(true) .build(); return ParseObject.from(newState); }
@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 testSynchronizeAllAuthData() throws Exception { // Register a mock currentUserController to make getCurrentUser work ParseUser currentUser = new ParseUser(); ParseCurrentUserController currentUserController = mock(ParseCurrentUserController.class); when(currentUserController.getAsync(anyBoolean())).thenReturn(Task.forResult(currentUser)); ParseCorePlugins.getInstance().registerCurrentUserController(currentUserController); // Register mock callbacks AuthenticationCallback callbacks = mock(AuthenticationCallback.class); when(callbacks.onRestore(Matchers.<Map<String, String>>any())) .thenReturn(true); ParseUser.registerAuthenticationCallback("facebook", callbacks); // Set user initial state String facebookAuthType = "facebook"; Map<String, String> facebookAuthData = new HashMap<>(); facebookAuthData.put("facebookToken", "facebookTest"); ParseUser.State userState = new ParseUser.State.Builder() .putAuthData(facebookAuthType, facebookAuthData) .build(); ParseUser user = ParseObject.from(userState); user.setIsCurrentUser(true); ParseTaskUtils.wait(user.synchronizeAllAuthDataAsync()); // Make sure we restore authentication verify(callbacks, times(1)).onRestore(facebookAuthData); }
@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 testLogOutAsync() throws Exception { // Register a mock sessionController to verify revokeAsync() NetworkSessionController sessionController = mock(NetworkSessionController.class); when(sessionController.revokeAsync(anyString())).thenReturn(Task.<Void>forResult(null)); ParseCorePlugins.getInstance().registerSessionController(sessionController); ParseAuthenticationManager manager = mock(ParseAuthenticationManager.class); when(manager.deauthenticateAsync(anyString())).thenReturn(Task.<Void>forResult(null)); ParseCorePlugins.getInstance().registerAuthenticationManager(manager); // Set user initial state String facebookAuthType = "facebook"; Map<String, String> facebookAuthData = new HashMap<>(); facebookAuthData.put("facebookToken", "facebookTest"); ParseUser.State userState = new ParseUser.State.Builder() .objectId("test") .putAuthData(facebookAuthType, facebookAuthData) .sessionToken("r:oldSessionToken") .build(); ParseUser user = ParseObject.from(userState); ParseTaskUtils.wait(user.logOutAsync()); verify(manager).deauthenticateAsync("facebook"); // Verify we revoke session verify(sessionController, times(1)).revokeAsync("r:oldSessionToken"); }
@Test public void testSaveAsyncWithLazyAndNotCurrentUser() 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); // Set facebook authData to null to verify cleanAuthData() ParseUser.State userState = new ParseUser.State.Builder() .putAuthData("facebook", null) .build(); ParseUser user = ParseObject.from(userState); setLazy(user); user.setIsCurrentUser(false); ParseUser partialMockUser = spy(user); doReturn(Task.<Void>forResult(null)) .when(partialMockUser) .resolveLazinessAsync(Matchers.<Task<Void>>any()); ParseTaskUtils.wait(partialMockUser.saveAsync("sessionToken", Task.<Void>forResult(null))); // Make sure we do not clean authData assertTrue(partialMockUser.getAuthData().containsKey("facebook")); // Make sure we do not save new currentUser verify(currentUserController, never()).setAsync(partialMockUser); }
@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()); }
@Test public void testSaveAsyncWithLazyAndCurrentUser() 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); // Set facebook authData to null to verify cleanAuthData() ParseUser.State userState = new ParseUser.State.Builder() .putAuthData("facebook", null) .build(); ParseUser user = ParseObject.from(userState); setLazy(user); user.setIsCurrentUser(true); ParseUser partialMockUser = spy(user); doReturn(Task.<Void>forResult(null)) .when(partialMockUser) .resolveLazinessAsync(Matchers.<Task<Void>>any()); ParseTaskUtils.wait(partialMockUser.saveAsync("sessionToken", Task.<Void>forResult(null))); // Make sure we clean authData assertFalse(partialMockUser.getAuthData().containsKey("facebook")); // Make sure we save new currentUser verify(currentUserController, times(1)).setAsync(partialMockUser); }
@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 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 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); }
@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 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 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 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()); }