@NotNull @Override public PrincipalIterator perform() { return principalManager.getGroupMembership(principal); } });
@Nonnull @Override public PrincipalIterator perform() { return principalManager.getGroupMembership(principal); } });
@NotNull @Override public PrincipalIterator perform() { return principalManager.getGroupMembership(principal); } });
@Override public void runTest() throws Exception { PrincipalManager principalManager = ((JackrabbitSession) session).getPrincipalManager(); for (int i = 0; i < 1000; i++) { Principal p = principalManager.getPrincipal(principalName); PrincipalIterator principals = principalManager.getGroupMembership(p); // while (principals.hasNext()) { // Principal groupPrincipal = principals.nextPrincipal(); // } } } }
private Set<Principal> getAuthorizablesToCheck(Authorizable authorizable, Context context) throws RepositoryException { Set<Principal> principals = new HashSet<>(); Principal principal = authorizable.getPrincipal(); principals.add(principal); for (PrincipalIterator it = (context.getSession()).getPrincipalManager() .getGroupMembership(principal); it.hasNext(); ) { principals.add(it.nextPrincipal()); } return principals; }
private Set<Principal> getAuthorizablesToCheck(Authorizable authorizable, Context context) throws RepositoryException { Set<Principal> principals = new HashSet<>(); Principal principal = authorizable.getPrincipal(); principals.add(principal); for (PrincipalIterator it = (context.getSession()).getPrincipalManager() .getGroupMembership(principal); it.hasNext(); ) { principals.add(it.nextPrincipal()); } return principals; }
public void testGetGroupMembership() throws RepositoryException { Principal principal = principalManager.getPrincipal(testPrincipalName); PrincipalIterator groups = principalManager.getGroupMembership(principal); // EXERCISE: what group principals do you expect here? }
private Principal[] getPrincipals(Credentials credentials) throws Exception { Set<Principal> principals = new HashSet<Principal>(); if (credentials instanceof SimpleCredentials) { Principal p = principalMgr.getPrincipal(((SimpleCredentials) credentials).getUserID()); if (p != null) { principals.add(p); PrincipalIterator principalIterator = principalMgr.getGroupMembership(p); while (principalIterator.hasNext()) { principals.add(principalIterator.nextPrincipal()); } } } return principals.toArray(new Principal[principals.size()]); }
public void testMyPrincipal() throws RepositoryException { String principalName = "myPrincipal"; // EXERCISE : fix the test case // HINT : take advantage of the default implemenation (i.e. it's relation to user management) try { Principal testPrincipal = principalManager.getPrincipal(principalName); assertNotNull(testPrincipal); Set<String> groupNames = Sets.newHashSet("myGroup", EveryonePrincipal.NAME); PrincipalIterator groups = principalManager.getGroupMembership(testPrincipal); while (groups.hasNext()) { groupNames.remove(groups.nextPrincipal().getName()); } assertTrue(groupNames.isEmpty()); } finally { // EXERCISE: cleanup } }
@Test public void testCorrespondance() { boolean exists = principalManager.hasPrincipal(testPrincipalName); Principal principal = principalManager.getPrincipal(testPrincipalName); PrincipalIterator principalIterator = principalManager.findPrincipals(testPrincipalName, PrincipalManager.SEARCH_TYPE_ALL); PrincipalIterator groups = principalManager.getGroupMembership(principal); PrincipalIterator all = principalManager.getPrincipals(PrincipalManager.SEARCH_TYPE_ALL); // EXERCISE: write the corresponding calls for the principal provider and verify the expected result // EXERCISE: which methods have nor corresponding call in the other interface? }
@Test public void testFindAuthorizable() throws RepositoryException, NotExecutableException { Set<Principal> principals = new HashSet<Principal>(); PrincipalManager pMgr = ((JackrabbitSession) superuser).getPrincipalManager(); Principal p = pMgr.getPrincipal(superuser.getUserID()); if (p != null) { principals.add(p); PrincipalIterator principalIterator = pMgr.getGroupMembership(p); while (principalIterator.hasNext()) { principals.add(principalIterator.nextPrincipal()); } } Authorizable auth; for (Principal principal : principals) { auth = userMgr.getAuthorizable(principal); if (auth != null) { if (!auth.isGroup() && auth.hasProperty(UserConstants.REP_PRINCIPAL_NAME)) { String val = auth.getProperty(UserConstants.REP_PRINCIPAL_NAME)[0].getString(); Iterator<Authorizable> users = userMgr.findAuthorizables(UserConstants.REP_PRINCIPAL_NAME, val); // the result must contain 1 authorizable assertTrue(users.hasNext()); Authorizable first = users.next(); assertEquals(first.getID(), val); // since id is unique -> there should be no more users in // the iterator left assertFalse(users.hasNext()); } } } }
public void testGetMembersConsistentWithMembership() { Principal everyone = principalMgr.getEveryone(); PrincipalIterator it = principalMgr.getPrincipals(PrincipalManager.SEARCH_TYPE_GROUP); while (it.hasNext()) { Principal p = it.nextPrincipal(); if (p.equals(everyone)) { continue; } assertTrue(isGroup(p)); Enumeration<? extends Principal> members = ((GroupPrincipal) p).members(); while (members.hasMoreElements()) { Principal memb = members.nextElement(); Principal group = null; PrincipalIterator mship = principalMgr.getGroupMembership(memb); while (mship.hasNext() && group == null) { Principal gr = mship.nextPrincipal(); if (p.equals(gr)) { group = gr; } } assertNotNull("Group member " + memb.getName() + "does not reveal group upon getGroupMembership", p.getName()); } } }
@Test public void testSystemUserPrincipal() throws RepositoryException { Authorizable authorizable = getUserManager(root).getAuthorizable(systemUser.getID()); // EXERCISE: what is the nature of the principal of the system user? Assert your expectedation. Principal principal = authorizable.getPrincipal(); PrincipalManager principalManager = getPrincipalManager(root); PrincipalIterator pIter = principalManager.getGroupMembership(principal); int expectedSize = -1; // EXERCISE assertEquals(expectedSize, pIter.getSize()); List<Principal> expectedGroupPrincipals = null; // EXERCISE while (pIter.hasNext()) { Principal group = pIter.nextPrincipal(); assertTrue(expectedGroupPrincipals.remove(group)); } assertTrue(expectedGroupPrincipals.isEmpty()); }
@Test public void testGetMembersConsistentWithMembership() { Principal everyone = principalMgr.getEveryone(); PrincipalIterator it = principalMgr.getPrincipals(PrincipalManager.SEARCH_TYPE_GROUP); while (it.hasNext()) { Principal p = it.nextPrincipal(); if (p.equals(everyone)) { continue; } assertTrue(isGroup(p)); Enumeration<? extends Principal> members = ((GroupPrincipal) p).members(); while (members.hasMoreElements()) { Principal memb = members.nextElement(); Principal group = null; PrincipalIterator mship = principalMgr.getGroupMembership(memb); while (mship.hasNext() && group == null) { Principal gr = mship.nextPrincipal(); if (p.equals(gr)) { group = gr; } } assertNotNull("Group member " + memb.getName() + "does not reveal group upon getGroupMembership", p.getName()); } } }
@Test public void testEveryoneGroupMembership() { Principal everyone = EveryonePrincipal.getInstance(); for (PrincipalIterator membership = principalMgr.getGroupMembership(everyone); membership.hasNext();) { Principal gr = membership.nextPrincipal(); assertTrue(isGroup(gr)); if (gr.equals(everyone)) { fail("Everyone must never be a member of the EveryOne group."); } } }
private static void assertMembership(@NotNull PrincipalManager mgr, int searchType) { PrincipalIterator it = mgr.getPrincipals(searchType); while (it.hasNext()) { Principal p = it.nextPrincipal(); if (p.equals(EveryonePrincipal.getInstance())) { continue; } boolean atleastEveryone = false; for (PrincipalIterator membership = mgr.getGroupMembership(p); membership.hasNext();) { Principal gr = membership.nextPrincipal(); assertTrue(isGroup(gr)); if (gr.equals(EveryonePrincipal.getInstance())) { atleastEveryone = true; } } assertTrue("All principals (except everyone) must be member of the everyone group.", atleastEveryone); } }
private void testMembership(int searchType) { PrincipalIterator it = principalMgr.getPrincipals(searchType); while (it.hasNext()) { Principal p = it.nextPrincipal(); if (p.equals(everyone)) { for (PrincipalIterator membership = principalMgr.getGroupMembership(p); membership.hasNext();) { Principal gr = membership.nextPrincipal(); assertTrue(isGroup(gr)); if (gr.equals(everyone)) { fail("Everyone must never be a member of the EveryOne group."); } } } else { boolean atleastEveryone = false; for (PrincipalIterator membership = principalMgr.getGroupMembership(p); membership.hasNext();) { Principal gr = membership.nextPrincipal(); assertTrue(isGroup(gr)); if (gr.equals(everyone)) { atleastEveryone = true; } } assertTrue("All principals (except everyone) must be member of the everyone group.", atleastEveryone); } } }
private void testMembership(int searchType) { PrincipalIterator it = principalMgr.getPrincipals(searchType); while (it.hasNext()) { Principal p = it.nextPrincipal(); if (p.equals(everyone)) { continue; } boolean atleastEveryone = false; for (PrincipalIterator membership = principalMgr.getGroupMembership(p); membership.hasNext();) { Principal gr = membership.nextPrincipal(); assertTrue(isGroup(gr)); if (gr.equals(everyone)) { atleastEveryone = true; } } assertTrue("All principals (except everyone) must be member of the everyone group.", atleastEveryone); } }
@Test public void testPrincipalManagerGetGroupMembershipPopulatesCache() throws Exception { PrincipalManager principalManager = getPrincipalManager(systemRoot); PrincipalIterator principalIterator = principalManager.getGroupMembership(getTestUser().getPrincipal()); assertPrincipals(ImmutableSet.copyOf(principalIterator), EveryonePrincipal.getInstance(), testGroup.getPrincipal()); root.refresh(); Tree principalCache = getCacheTree(root); assertTrue(principalCache.exists()); assertEquals(CacheConstants.NT_REP_CACHE, TreeUtil.getPrimaryTypeName(principalCache)); assertNotNull(principalCache.getProperty(CacheConstants.REP_EXPIRATION)); PropertyState ps = principalCache.getProperty(CacheConstants.REP_GROUP_PRINCIPAL_NAMES); assertNotNull(ps); String val = ps.getValue(Type.STRING); assertEquals(testGroup.getPrincipal().getName(), val); }
for (PrincipalIterator it = pmgr.getGroupMembership(gr3.getPrincipal()); it.hasNext() && !isMember;) { isMember = it.nextPrincipal().equals(gr1.getPrincipal());