private static void assertTrueMemberOfContainsGroup(Iterator<Group> groups, Group gr) throws RepositoryException { boolean contained = false; while (groups.hasNext() && !contained) { Object next = groups.next(); assertTrue(next instanceof Group); contained = ((Group)next).getID().equals(gr.getID()); } assertTrue("All members of a group must contain that group upon 'memberOf'.", contained); }
public void testAddMemberModifiesMemberOf() throws NotExecutableException, RepositoryException { User auth = getTestUser(superuser); Group newGroup = null; try { newGroup = userMgr.createGroup(getTestPrincipal()); save(superuser); assertFalseMemberOfContainsGroup(auth.memberOf(), newGroup); assertTrue(newGroup.addMember(auth)); save(superuser); assertTrueMemberOfContainsGroup(auth.declaredMemberOf(), newGroup); assertTrueMemberOfContainsGroup(auth.memberOf(), newGroup); } finally { if (newGroup != null) { newGroup.removeMember(auth); newGroup.remove(); save(superuser); } } }
public void testAddMemberModifiesGetMembers() throws NotExecutableException, RepositoryException { User auth = getTestUser(superuser); Group newGroup = null; try { newGroup = userMgr.createGroup(getTestPrincipal()); save(superuser); assertFalseIsMember(newGroup.getMembers(), auth); assertFalseIsMember(newGroup.getDeclaredMembers(), auth); assertTrue(newGroup.addMember(auth)); save(superuser); assertTrueIsMember(newGroup.getMembers(), auth); assertTrueIsMember(newGroup.getDeclaredMembers(), auth); } finally { if (newGroup != null) { newGroup.removeMember(auth); newGroup.remove(); save(superuser); } } }
assertTrue(newGroup.isMember(newGroup2));
private static void assertTrueIsMember(Iterator<Authorizable> members, Authorizable auth) throws RepositoryException { boolean contained = false; while (members.hasNext() && !contained) { Object next = members.next(); assertTrue(next instanceof Authorizable); contained = ((Authorizable)next).getID().equals(auth.getID()); } assertTrue("The given set of members must contain '" + auth.getID() + "'", contained); }
private static void assertFalseMemberOfContainsGroup(Iterator<Group> groups, Group gr) throws RepositoryException { boolean contained = false; while (groups.hasNext() && !contained) { Object next = groups.next(); assertTrue(next instanceof Group); contained = ((Group)next).getID().equals(gr.getID()); } assertFalse("All members of a group must contain that group upon 'memberOf'.", contained); }
public void testGetMembersContainsDeclaredMembers() throws NotExecutableException, RepositoryException { Group gr = getTestGroup(superuser); List<String> l = new ArrayList<String>(); for (Iterator<Authorizable> it = gr.getMembers(); it.hasNext();) { l.add(it.next().getID()); } for (Iterator<Authorizable> it = gr.getDeclaredMembers(); it.hasNext();) { assertTrue("All declared members must also be part of the Iterator " + "returned upon getMembers()",l.contains(it.next().getID())); } }
public void testGetDeclaredMembers() throws NotExecutableException, RepositoryException { Group gr = getTestGroup(superuser); Iterator<Authorizable> it = gr.getDeclaredMembers(); assertNotNull(it); while (it.hasNext()) { assertTrue(it.next() != null); } }
public void testGetMembers() throws NotExecutableException, RepositoryException { Group gr = getTestGroup(superuser); Iterator<Authorizable> it = gr.getMembers(); assertNotNull(it); while (it.hasNext()) { assertTrue(it.next() != null); } }
public void testGetMembersAgainstIsMember() throws NotExecutableException, RepositoryException { Group gr = getTestGroup(superuser); Iterator<Authorizable> it = gr.getMembers(); while (it.hasNext()) { Authorizable auth = it.next(); assertTrue(gr.isMember(auth)); } }
public void testIsGroup() throws NotExecutableException, RepositoryException { Group gr = getTestGroup(superuser); assertTrue(gr.isGroup()); }
private static void assertFalseIsMember(Iterator<Authorizable> members, Authorizable auth) throws RepositoryException { boolean contained = false; while (members.hasNext() && !contained) { Object next = members.next(); assertTrue(next instanceof Authorizable); contained = ((Authorizable)next).getID().equals(auth.getID()); } assertFalse("The given set of members must not contain '" + auth.getID() + "'", contained); }
assertTrue(declaredMembers.hasNext()); declaredMembers.next(); assertFalse(declaredMembers.hasNext()); for (Iterator<Authorizable> it = topGroup.getMembers(); it.hasNext(); ) { Authorizable a = it.next(); assertTrue(a.equals(auth) || allGroups.remove(a)); assertTrue(allGroups.isEmpty()); } finally { for (Group g : groups) {
public void testInheritedMembers() throws Exception { Set<Authorizable> authorizables = new HashSet<Authorizable>(); try { User testUser = userMgr.createUser(getTestPrincipal().getName(), "pw"); authorizables.add(testUser); Group group1 = userMgr.createGroup(getTestPrincipal()); authorizables.add(group1); Group group2 = userMgr.createGroup(getTestPrincipal()); authorizables.add(group2); Group group3 = userMgr.createGroup(getTestPrincipal()); group1.addMember(testUser); group2.addMember(testUser); group3.addMember(group1); group3.addMember(group2); Iterator<Authorizable> members = group3.getMembers(); while (members.hasNext()) { Authorizable a = members.next(); assertTrue(authorizables.contains(a)); assertTrue(authorizables.remove(a)); } assertTrue(authorizables.isEmpty()); } finally { for (Authorizable a : authorizables) { a.remove(); } } }
save(superuser); assertTrue(newGroup.addMember(auth)); save(superuser); isMember = groupId.equals(it.next().getID()); assertTrue(isMember);
public void testAddMember() throws NotExecutableException, RepositoryException { User auth = getTestUser(superuser); Group newGroup = null; try { newGroup = userMgr.createGroup(getTestPrincipal()); save(superuser); assertFalse(newGroup.isMember(auth)); assertFalse(newGroup.removeMember(auth)); save(superuser); assertTrue(newGroup.addMember(auth)); save(superuser); assertTrue(newGroup.isMember(auth)); assertTrue(newGroup.isMember(userMgr.getAuthorizable(auth.getID()))); } finally { if (newGroup != null) { newGroup.removeMember(auth); newGroup.remove(); save(superuser); } } }
public void testAddMemberTwice() throws NotExecutableException, RepositoryException { User auth = getTestUser(superuser); Group newGroup = null; try { newGroup = userMgr.createGroup(getTestPrincipal()); save(superuser); assertTrue(newGroup.addMember(auth)); save(superuser); assertFalse(newGroup.addMember(auth)); save(superuser); assertTrue(newGroup.isMember(auth)); } finally { if (newGroup != null) { newGroup.removeMember(auth); newGroup.remove(); save(superuser); } } }
public void testRemoveMemberTwice() throws NotExecutableException, RepositoryException { User auth = getTestUser(superuser); Group newGroup = null; try { newGroup = userMgr.createGroup(getTestPrincipal()); save(superuser); assertTrue(newGroup.addMember(auth)); save(superuser); assertTrue(newGroup.removeMember(userMgr.getAuthorizable(auth.getID()))); save(superuser); assertFalse(newGroup.removeMember(auth)); save(superuser); } finally { if (newGroup != null) { newGroup.remove(); save(superuser); } } }
public void testCyclicGroups() throws AuthorizableExistsException, RepositoryException, NotExecutableException { Group group1 = null; Group group2 = null; Group group3 = null; try { group1 = userMgr.createGroup(getTestPrincipal()); group2 = userMgr.createGroup(getTestPrincipal()); group3 = userMgr.createGroup(getTestPrincipal()); group1.addMember(getTestUser(superuser)); group2.addMember(getTestUser(superuser)); assertTrue(group1.addMember(group2)); assertTrue(group2.addMember(group3)); assertFalse(group3.addMember(group1)); } finally { if (group1 != null) group1.remove(); if (group2 != null) group2.remove(); if (group3 != null) group3.remove(); } }
/** * Removing a GroupImpl must be possible even if there are still existing * members present. * * @throws RepositoryException if an error occurs * @throws NotExecutableException if not executable */ public void testRemoveGroupIfMemberExist() throws RepositoryException, NotExecutableException { User auth = getTestUser(superuser); String newGroupId = null; try { Group newGroup = userMgr.createGroup(getTestPrincipal()); save(superuser); newGroupId = newGroup.getID(); assertTrue(newGroup.addMember(auth)); newGroup.remove(); save(superuser); } finally { Group gr = (Group) userMgr.getAuthorizable(newGroupId); if (gr != null) { gr.removeMember(auth); gr.remove(); save(superuser); } } }