/** * Set whether the public is allowed to write this object. */ public void setPublicWriteAccess(boolean allowed) { setWriteAccess(PUBLIC_KEY, allowed); }
/** * Set whether users belonging to the role with the given roleName are allowed to write this * object. * * @param roleName The name of the role. * @param allowed Whether the given role can write this object. */ public void setRoleWriteAccess(String roleName, boolean allowed) { setWriteAccess(KEY_ROLE_PREFIX + roleName, allowed); }
/** * Creates an ACL where only the provided user has access. * * @param owner The only user that can read or write objects governed by this ACL. */ public ParseACL(ParseUser owner) { this(); setReadAccess(owner, true); setWriteAccess(owner, true); }
private void setUnresolvedWriteAccess(ParseUser user, boolean allowed) { prepareUnresolvedUser(user); setWriteAccess(UNRESOLVED_KEY, allowed); }
/** * Set whether the given user is allowed to write this object. */ public void setWriteAccess(ParseUser user, boolean allowed) { if (user.getObjectId() == null) { if (user.isLazy()) { setUnresolvedWriteAccess(user, allowed); return; } throw new IllegalArgumentException("cannot setWriteAccess for a user with null id"); } setWriteAccess(user.getObjectId(), allowed); }
public ParseACL get() { if (defaultACLUsesCurrentUser && defaultACL != null) { ParseUser currentUser = ParseUser.getCurrentUser(); if (currentUser != null) { // If the currentUser has changed, generate a new ACL from the defaultACL. ParseUser last = lastCurrentUser != null ? lastCurrentUser.get() : null; if (last != currentUser) { ParseACL newDefaultACLWithCurrentUser = defaultACL.copy(); newDefaultACLWithCurrentUser.setShared(true); newDefaultACLWithCurrentUser.setReadAccess(currentUser, true); newDefaultACLWithCurrentUser.setWriteAccess(currentUser, true); defaultACLWithCurrentUser = newDefaultACLWithCurrentUser; lastCurrentUser = new WeakReference<>(currentUser); } return defaultACLWithCurrentUser; } } return defaultACL; }
@Test(expected = IllegalArgumentException.class) public void testSetWriteAccessWithNullUserId() { ParseACL acl = new ParseACL(); String userId = null; acl.setWriteAccess(userId, true); }
@Test(expected = IllegalArgumentException.class) public void testSetUserWriteAccessWithNotSavedNotLazyUser() { ParseUser user = new ParseUser(); ParseACL acl = new ParseACL(); acl.setWriteAccess(user, true); }
@Test public void testSetUserWriteAccessWithLazyUser() { ParseUser user = mock(ParseUser.class); when(user.isLazy()).thenReturn(true); ParseACL acl = new ParseACL(); acl.setWriteAccess(user, true); assertSame(user, acl.getUnresolvedUser()); verify(user, times(1)).registerSaveListener(any(GetCallback.class)); assertTrue(acl.getPermissionsById().containsKey(UNRESOLVED_KEY)); assertTrue(acl.getWriteAccess(user)); assertEquals(1, acl.getPermissionsById().size()); } //endregion
@Test public void testGetDefaultACLWithCurrentUserAndLastCurrentUserNotSame() { ParseDefaultACLController controller = new ParseDefaultACLController(); ParseACL acl = mock(ParseACL.class); ParseACL copiedACL = mock(ParseACL.class); when(acl.copy()).thenReturn(copiedACL); controller.defaultACL = acl; controller.defaultACLUsesCurrentUser = true; controller.defaultACLWithCurrentUser = new ParseACL(); // Register currentUser ParseCurrentUserController currentUserController = mock(ParseCurrentUserController.class); ParseUser currentUser = mock(ParseUser.class); when(currentUserController.getAsync(anyBoolean())).thenReturn(Task.forResult(currentUser)); ParseCorePlugins.getInstance().registerCurrentUserController(currentUserController); ParseACL defaultACL = controller.get(); verify(copiedACL, times(1)).setShared(true); verify(copiedACL, times(1)).setReadAccess(eq(currentUser), eq(true)); verify(copiedACL, times(1)).setWriteAccess(eq(currentUser), eq(true)); assertSame(currentUser, controller.lastCurrentUser.get()); assertNotSame(acl, defaultACL); assertSame(copiedACL, defaultACL); }
acl.setWriteAccess(unresolvedUser, true);
@Test public void testCopy() { ParseACL acl = new ParseACL(); final ParseUser unresolvedUser = mock(ParseUser.class); when(unresolvedUser.isLazy()).thenReturn(true); // This will set unresolvedUser and permissionsById acl.setReadAccess(unresolvedUser, true); acl.setWriteAccess(unresolvedUser, true); // We need to reset unresolvedUser since registerSaveListener will be triggered once in // setReadAccess() reset(unresolvedUser); ParseACL copiedACL = new ParseACL(acl); assertEquals(1, copiedACL.getPermissionsById().size()); assertTrue(copiedACL.getPermissionsById().containsKey(UNRESOLVED_KEY)); assertTrue(copiedACL.getReadAccess(unresolvedUser)); assertTrue(copiedACL.getWriteAccess(unresolvedUser)); assertFalse(copiedACL.isShared()); assertSame(unresolvedUser, copiedACL.getUnresolvedUser()); verify(unresolvedUser, times(1)).registerSaveListener(any(GetCallback.class)); }
@Test public void testSetUserWriteAccessWithNormalUser() { ParseUser user = new ParseUser(); user.setObjectId("test"); ParseACL acl = new ParseACL(); acl.setWriteAccess(user, true); assertTrue(acl.getWriteAccess(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 testGetUserWriteAccessWithNormalUser() { ParseACL acl = new ParseACL(); ParseUser user = new ParseUser(); user.setObjectId("test"); acl.setWriteAccess(user, true); assertTrue(acl.getWriteAccess(user)); }
@Test public void testResolveUserWithUnresolvedUser() { ParseACL acl = new ParseACL(); ParseUser unresolvedUser = new ParseUser(); setLazy(unresolvedUser); // This will set the unresolvedUser in acl acl.setReadAccess(unresolvedUser, true); acl.setWriteAccess(unresolvedUser, true); unresolvedUser.setObjectId("test"); acl.resolveUser(unresolvedUser); assertNull(acl.getUnresolvedUser()); assertTrue(acl.getReadAccess(unresolvedUser)); assertTrue(acl.getWriteAccess(unresolvedUser)); assertEquals(1, acl.getPermissionsById().size()); assertFalse(acl.getPermissionsById().containsKey(UNRESOLVED_KEY)); }