@Test(expected = IllegalArgumentException.class) public void testSetUserReadAccessWithNotSavedNotLazyUser() { ParseUser user = new ParseUser(); ParseACL acl = new ParseACL(); acl.setReadAccess(user, true); }
@Test(expected = IllegalArgumentException.class) public void testGetUserReadAccessWithNotSavedUser() { ParseACL acl = new ParseACL(); ParseUser user = new ParseUser(); assertFalse(acl.getReadAccess(user)); }
@Test public void testRemoveWithUserName() { ParseUser user = new ParseUser(); thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Can't remove the username key."); user.remove("username"); }
@Test public void testValidateSaveWithNoObjectId() { ParseUser user = new ParseUser(); thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Cannot save a ParseUser until it has been signed up. Call signUp first."); user.validateSave(); }
@Test public void testPinCurrentUserIfNeededAsyncWithNoLDSEnabled() { thrown.expect(IllegalStateException.class); thrown.expectMessage("Method requires Local Datastore."); ParseUser.pinCurrentUserIfNeededAsync(new ParseUser()); }
@Test public void testGetAsyncWithInMemoryCurrentUserSet() throws Exception { ParseUser currentUserInMemory = new ParseUser(); CachedCurrentUserController controller = new CachedCurrentUserController(null); controller.currentUser = currentUserInMemory; ParseUser currentUser = ParseTaskUtils.wait(controller.getAsync(false)); assertSame(currentUserInMemory, currentUser); }
@Test public void testGetUserReadAccessWithLazyUser() { ParseACL acl = new ParseACL(); ParseUser user = new ParseUser(); setLazy(user); assertFalse(acl.getReadAccess(user)); }
@Test public void testExistsAsyncWithInMemoryCurrentUserSet() throws Exception { CachedCurrentUserController controller = new CachedCurrentUserController(null); controller.currentUser = new ParseUser(); assertTrue(ParseTaskUtils.wait(controller.existsAsync())); }
@Test public void testSignUpAsyncWithNoPassword() 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 user = new ParseUser(); user.setUsername("userName"); thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Password cannot be missing or blank"); ParseTaskUtils.wait(user.signUpAsync(Task.<Void>forResult(null))); }
@Test public void testSetUserReadAccessWithNormalUser() { ParseUser user = new ParseUser(); user.setObjectId("test"); ParseACL acl = new ParseACL(); acl.setReadAccess(user, true); assertTrue(acl.getReadAccess(user)); assertEquals(1, acl.getPermissionsById().size()); }
@Test public void testGetUserWriteAccessWithUnresolvedUser() { ParseACL acl = new ParseACL(); ParseUser user = new ParseUser(); setLazy(user); // Since user is a lazy user, this will set the acl's unresolved user and give it write access acl.setWriteAccess(user, true); assertTrue(acl.getWriteAccess(user)); }
@Test public void testGetUserReadAccessWithUnresolvedUser() { ParseACL acl = new ParseACL(); ParseUser user = new ParseUser(); setLazy(user); // Since user is a lazy user, this will set the acl's unresolved user and give it read access acl.setReadAccess(user, true); assertTrue(acl.getReadAccess(user)); }
@Test public void testGetUserReadAccessWithNormalUser() { ParseACL acl = new ParseACL(); ParseUser user = new ParseUser(); user.setObjectId("test"); acl.setReadAccess(user, true); assertTrue(acl.getReadAccess(user)); }
@Test public void testGetUserWriteAccessWithNormalUser() { ParseACL acl = new ParseACL(); ParseUser user = new ParseUser(); user.setObjectId("test"); acl.setWriteAccess(user, true); assertTrue(acl.getWriteAccess(user)); }
@Test public void testConstructorWithUser() { ParseUser user = new ParseUser(); user.setObjectId("test"); ParseACL acl = new ParseACL(user); assertTrue(acl.getReadAccess("test")); assertTrue(acl.getWriteAccess("test")); }
@Test public void testAutomaticUser() { new ParseUser(); ParseUser.disableAutomaticUser(); assertFalse(ParseUser.isAutomaticUserEnabled()); ParseUser.enableAutomaticUser(); assertTrue(ParseUser.isAutomaticUserEnabled()); }
@Test public void testUnresolvedUser() { ParseACL acl = new ParseACL(); ParseUser user = new ParseUser(); setLazy(user); // This will set unresolvedUser in acl acl.setReadAccess(user, true); assertTrue(acl.hasUnresolvedUser()); assertSame(user, acl.getUnresolvedUser()); } }
@Test public void testOnSaveRestoreState() { ParseUser user = new ParseUser(); user.setObjectId("objId"); user.setIsCurrentUser(true); Parcel parcel = Parcel.obtain(); user.writeToParcel(parcel, 0); parcel.setDataPosition(0); user = (ParseUser) ParseObject.CREATOR.createFromParcel(parcel); assertTrue(user.isCurrentUser()); }
@Test public void testSetUser() throws ParseException { ParseQuery<ParseObject> query = ParseQuery.getQuery("TestObject"); ParseUser user = new ParseUser(); query.setUser(user); assertSame(user, ParseTaskUtils.wait(query.getUserAsync(query.getBuilder().build()))); // TODO(grantland): Test that it gets the current user Parse.enableLocalDatastore(null); query.fromLocalDatastore() .ignoreACLs(); assertNull(ParseTaskUtils.wait(query.getUserAsync(query.getBuilder().build()))); }