Author: angela
Date: Tue Feb 28 14:31:55 2017
New Revision: 1784743
URL: http://svn.apache.org/viewvc?rev=1784743&view=rev
Log:
OAK-5793 : Improve coverage for security code in oak-core (wip)
Added:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/PrincipalManagerImplTest.java
- copied, changed from r1784697,
jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/security/principal/PrincipalManagerTest.java
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/SystemPrincipalTest.java
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/TestPrincipalProvider.java
Modified:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/authentication/credentials/SimpleCredentialsSupportTest.java
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/CompositePrincipalProviderTest.java
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/EmptyPrincipalProviderTest.java
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/EveryonePrincipalTest.java
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/PrincipalImplTest.java
Modified:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/authentication/credentials/SimpleCredentialsSupportTest.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/authentication/credentials/SimpleCredentialsSupportTest.java?rev=1784743&r1=1784742&r2=1784743&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/authentication/credentials/SimpleCredentialsSupportTest.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/authentication/credentials/SimpleCredentialsSupportTest.java
Tue Feb 28 14:31:55 2017
@@ -92,5 +92,26 @@ public class SimpleCredentialsSupportTes
assertEquals(expected, attributes);
}
+ @Test
+ public void testSetAttributes() {
+ Map<String, ?> attributes = credentialsSupport.getAttributes(new
TestCredentials());
+ assertNotNull(attributes);
+ assertTrue(attributes.isEmpty());
+
+ SimpleCredentials sc = new SimpleCredentials("uid", new char[0]);
+
+ Map<String, ?> expected = ImmutableMap.of("a", "a", "b", Boolean.TRUE,
"c", new TestCredentials());
+ credentialsSupport.setAttributes(sc, expected);
+
+ for (Map.Entry<String, ?> entry : expected.entrySet()) {
+ assertEquals(entry.getValue(), sc.getAttribute(entry.getKey()));
+ }
+
+ attributes = credentialsSupport.getAttributes(sc);
+ assertNotNull(attributes);
+ assertEquals(3, attributes.size());
+ assertEquals(expected, attributes);
+ }
+
private static final class TestCredentials implements Credentials {}
}
\ No newline at end of file
Modified:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/CompositePrincipalProviderTest.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/CompositePrincipalProviderTest.java?rev=1784743&r1=1784742&r2=1784743&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/CompositePrincipalProviderTest.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/CompositePrincipalProviderTest.java
Tue Feb 28 14:31:55 2017
@@ -16,16 +16,38 @@
*/
package org.apache.jackrabbit.oak.spi.security.principal;
+import java.security.Principal;
+import java.security.acl.Group;
+import java.util.Iterator;
+import javax.annotation.Nonnull;
+
+import com.google.common.base.Predicate;
import com.google.common.collect.ImmutableList;
-import org.apache.jackrabbit.oak.AbstractSecurityTest;
-import org.apache.jackrabbit.oak.namepath.NamePathMapper;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import org.apache.jackrabbit.api.security.principal.PrincipalManager;
import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
-public class CompositePrincipalProviderTest extends AbstractSecurityTest{
+public class CompositePrincipalProviderTest {
+
+ private final TestPrincipalProvider pp1 = new TestPrincipalProvider();
+ private final TestPrincipalProvider pp2 = new TestPrincipalProvider("p1",
"p2");
+ private final PrincipalProvider cpp =
CompositePrincipalProvider.of(ImmutableList.<PrincipalProvider>of(pp1, pp2));
+
+ private Iterable<Principal> testPrincipals() {
+ return Iterables.concat(pp1.getTestPrincipals(),
pp2.getTestPrincipals());
+ }
+
+ private static void assertIterator(@Nonnull Iterable<? extends Principal>
expected, @Nonnull Iterator<? extends Principal> result) {
+ assertEquals(ImmutableSet.copyOf(expected),
ImmutableSet.copyOf(result));
+ }
@Test
public void testOfEmptyList() {
@@ -34,16 +56,83 @@ public class CompositePrincipalProviderT
@Test
public void testOfSingletonList() {
- PrincipalProvider pp =
getSecurityProvider().getConfiguration(PrincipalConfiguration.class).getPrincipalProvider(root,
NamePathMapper.DEFAULT);
+ PrincipalProvider pp = new TestPrincipalProvider(true);
assertSame(pp, CompositePrincipalProvider.of(ImmutableList.of(pp)));
}
@Test
public void testOfList() {
- PrincipalProvider pp =
getSecurityProvider().getConfiguration(PrincipalConfiguration.class).getPrincipalProvider(root,
NamePathMapper.DEFAULT);
+ assertNotSame(pp1, cpp);
+ assertNotSame(pp2, cpp);
+ assertTrue(cpp instanceof CompositePrincipalProvider);
+ }
+
+ @Test
+ public void getPrincipalUnknown() {
+ assertNull(cpp.getPrincipal(TestPrincipalProvider.UNKNOWN.getName()));
+ }
+
+ @Test
+ public void getPrincipal() {
+ for (Principal principal : testPrincipals()) {
+ assertEquals(principal, cpp.getPrincipal(principal.getName()));
+ }
+ }
+
+ @Test
+ public void getGroupMembership() {
+ for (Principal principal : testPrincipals()) {
+ boolean atleastEveryone =
cpp.getGroupMembership(principal).contains(EveryonePrincipal.getInstance());
+ assertTrue("All principals (except everyone) must be member of the
everyone group. Violation: "+principal.getName(), atleastEveryone);
+ }
+ }
+
+ @Test
+ public void getGroupMembershipUnknown() {
+
assertTrue(cpp.getGroupMembership(TestPrincipalProvider.UNKNOWN).isEmpty());
+ }
+
+ @Test
+ public void testGetPrincipalsByUnknownId() {
+
assertTrue(cpp.getPrincipals(TestPrincipalProvider.getIDFromPrincipal(TestPrincipalProvider.UNKNOWN)).isEmpty());
+ }
- PrincipalProvider of =
CompositePrincipalProvider.of(ImmutableList.of(pp, pp));
- assertNotSame(pp, of);
- assertTrue(of instanceof CompositePrincipalProvider);
+ @Test
+ public void findPrincipalsUnknown() {
+
assertFalse(cpp.findPrincipals(TestPrincipalProvider.UNKNOWN.getName(),
PrincipalManager.SEARCH_TYPE_ALL).hasNext());
+
assertFalse(cpp.findPrincipals(TestPrincipalProvider.UNKNOWN.getName(),
PrincipalManager.SEARCH_TYPE_NOT_GROUP).hasNext());
+
assertFalse(cpp.findPrincipals(TestPrincipalProvider.UNKNOWN.getName(),
PrincipalManager.SEARCH_TYPE_GROUP).hasNext());
+ }
+
+ @Test
+ public void findPrincipalsByTypeGroup() {
+ Iterable<? extends Principal> expected =
Iterables.concat(ImmutableSet.of(EveryonePrincipal.getInstance()),
Iterables.filter(testPrincipals(), new Predicate<Principal>() {
+ @Override
+ public boolean apply(Principal input) {
+ return input instanceof Group;
+ }
+ }));
+
+ Iterator<? extends Principal> result =
cpp.findPrincipals(PrincipalManager.SEARCH_TYPE_GROUP);
+ assertIterator(expected, result);
+ }
+
+ @Test
+ public void findPrincipalsByTypeNotGroup() {
+ Iterable<? extends Principal> expected =
Iterables.filter(testPrincipals(), new Predicate<Principal>() {
+ @Override
+ public boolean apply(Principal input) {
+ return !(input instanceof Group);
+ }
+ });
+
+ Iterator<? extends Principal> result =
cpp.findPrincipals(PrincipalManager.SEARCH_TYPE_NOT_GROUP);
+ assertIterator(expected, result);
+ }
+
+ @Test
+ public void findPrincipalsByTypeAll() {
+ Iterator<? extends Principal> result =
cpp.findPrincipals(PrincipalManager.SEARCH_TYPE_ALL);
+
assertIterator(Iterables.concat(ImmutableSet.of(EveryonePrincipal.getInstance()),
testPrincipals()), result);
}
}
\ No newline at end of file
Modified:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/EmptyPrincipalProviderTest.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/EmptyPrincipalProviderTest.java?rev=1784743&r1=1784742&r2=1784743&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/EmptyPrincipalProviderTest.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/EmptyPrincipalProviderTest.java
Tue Feb 28 14:31:55 2017
@@ -19,23 +19,17 @@ package org.apache.jackrabbit.oak.spi.se
import java.security.Principal;
import org.apache.jackrabbit.api.security.principal.PrincipalManager;
-import org.apache.jackrabbit.oak.AbstractSecurityTest;
import org.junit.Test;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
-public class EmptyPrincipalProviderTest extends AbstractSecurityTest {
+public class EmptyPrincipalProviderTest {
private PrincipalProvider principalProvider =
EmptyPrincipalProvider.INSTANCE;
- private Principal testPrincipal;
+ private Principal testPrincipal = new PrincipalImpl("testUser");
- @Override
- public void before() throws Exception {
- super.before();
- testPrincipal = getTestUser().getPrincipal();
- }
@Test
public void testGetPrincipal() {
@@ -52,7 +46,7 @@ public class EmptyPrincipalProviderTest
@Test
public void testGetPrincipals() throws Exception {
-
assertTrue(principalProvider.getPrincipals(getTestUser().getID()).isEmpty());
+ assertTrue(principalProvider.getPrincipals("userId").isEmpty());
}
@Test
Modified:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/EveryonePrincipalTest.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/EveryonePrincipalTest.java?rev=1784743&r1=1784742&r2=1784743&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/EveryonePrincipalTest.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/EveryonePrincipalTest.java
Tue Feb 28 14:31:55 2017
@@ -24,6 +24,8 @@ import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
@@ -103,6 +105,12 @@ public class EveryonePrincipalTest {
assertEquals(everyone, someotherEveryone);
}
+ @Test
+ public void testToString() {
+ assertNotNull(everyone.toString());
+ assertNotEquals(EveryonePrincipal.NAME, everyone.toString());
+ }
+
//--------------------------------------------------------------------------
private class OtherEveryone implements JackrabbitPrincipal {
Modified:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/PrincipalImplTest.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/PrincipalImplTest.java?rev=1784743&r1=1784742&r2=1784743&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/PrincipalImplTest.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/PrincipalImplTest.java
Tue Feb 28 14:31:55 2017
@@ -25,6 +25,8 @@ import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
/**
@@ -77,6 +79,13 @@ public class PrincipalImplTest {
}
}
+ @Test
+ public void testToString() {
+ assertNotNull(principal.toString());
+ assertTrue(principal.toString().endsWith(principal.getName()));
+
assertTrue(principal.toString().startsWith(principal.getClass().getName()));
+ }
+
//--------------------------------------------------------------------------
private class TestPrincipal extends PrincipalImpl {
Copied:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/PrincipalManagerImplTest.java
(from r1784697,
jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/security/principal/PrincipalManagerTest.java)
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/PrincipalManagerImplTest.java?p2=jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/PrincipalManagerImplTest.java&p1=jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/security/principal/PrincipalManagerTest.java&r1=1784697&r2=1784743&rev=1784743&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/security/principal/PrincipalManagerTest.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/PrincipalManagerImplTest.java
Tue Feb 28 14:31:55 2017
@@ -14,141 +14,100 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.jackrabbit.oak.jcr.security.principal;
+package org.apache.jackrabbit.oak.spi.security.principal;
import java.security.Principal;
import java.security.acl.Group;
import java.util.Enumeration;
-import java.util.HashSet;
-import java.util.Set;
-import javax.jcr.Credentials;
-import javax.jcr.Session;
-import javax.jcr.SimpleCredentials;
+import java.util.Iterator;
+import javax.annotation.Nonnull;
-import org.apache.jackrabbit.api.JackrabbitSession;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterators;
import org.apache.jackrabbit.api.security.principal.PrincipalIterator;
import org.apache.jackrabbit.api.security.principal.PrincipalManager;
-import org.apache.jackrabbit.api.security.user.Authorizable;
-import org.apache.jackrabbit.oak.spi.security.principal.EveryonePrincipal;
-import org.apache.jackrabbit.test.AbstractJCRTest;
-import org.apache.jackrabbit.test.NotExecutableException;
-import org.junit.Before;
import org.junit.Test;
-/**
- * {@code PrincipalManagerTest}...
- */
-public class PrincipalManagerTest extends AbstractJCRTest {
-
- private PrincipalManager principalMgr;
- private Group everyone;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+public class PrincipalManagerImplTest {
+
+ private final TestPrincipalProvider provider = new TestPrincipalProvider();
+ private final PrincipalManagerImpl principalMgr = new
PrincipalManagerImpl(provider);
+ private Iterable<Principal> testPrincipals = provider.getTestPrincipals();
- private Principal[] adminPrincipals;
-
- @Before
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- if (!(superuser instanceof JackrabbitSession)) {
- superuser.logout();
- throw new NotExecutableException();
- }
- principalMgr = ((JackrabbitSession) superuser).getPrincipalManager();
- everyone = (Group) principalMgr.getEveryone();
-
- adminPrincipals = getPrincipals(getHelper().getSuperuserCredentials());
- }
-
- 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()]);
+ private static boolean isGroup(Principal p) {
+ return p instanceof Group;
}
- private static boolean isGroup(Principal p) {
- return p instanceof java.security.acl.Group;
+ private static void assertIterator(@Nonnull Iterator<? extends Principal>
expected, @Nonnull Iterator<? extends Principal> result) {
+ assertEquals(ImmutableSet.copyOf(expected),
ImmutableSet.copyOf(result));
}
@Test
public void testGetEveryone() {
Principal principal = principalMgr.getEveryone();
- assertTrue(principal != null);
assertTrue(isGroup(principal));
}
- /**
- * @since oak
- */
@Test
- public void testGetEveryoneByName() {
- assertTrue(principalMgr.hasPrincipal(EveryonePrincipal.NAME));
- assertNotNull(principalMgr.getPrincipal(EveryonePrincipal.NAME));
- assertEquals(EveryonePrincipal.getInstance(),
principalMgr.getPrincipal(EveryonePrincipal.NAME));
+ public void testGetEveryone2() {
+ Principal principal = new PrincipalManagerImpl(new
TestPrincipalProvider(false)).getEveryone();
+ assertSame(EveryonePrincipal.getInstance(), principal);
}
@Test
- public void testSuperUserIsEveryOne() {
- for (Principal pcpl : adminPrincipals) {
- if (!(pcpl.equals(everyone))) {
- assertTrue(everyone.isMember(pcpl));
- }
- }
+ public void testGetPrincipalEveryone() {
+ assertEquals(EveryonePrincipal.getInstance(),
principalMgr.getPrincipal(EveryonePrincipal.NAME));
}
@Test
- public void testReadOnlyIsEveryOne() throws Exception {
- Session s = getHelper().getReadOnlySession();
- try {
- Principal[] pcpls =
getPrincipals(getHelper().getReadOnlyCredentials());
- for (Principal pcpl : pcpls) {
- if (!(pcpl.equals(everyone))) {
- assertTrue(everyone.isMember(pcpl));
- }
- }
- } finally {
- s.logout();
- }
+ public void testHasPrincipalEveryone() {
+ assertTrue(principalMgr.hasPrincipal(EveryonePrincipal.NAME));
}
@Test
public void testHasPrincipal() {
- assertTrue(principalMgr.hasPrincipal(everyone.getName()));
-
- for (Principal pcpl : adminPrincipals) {
+ for (Principal pcpl : testPrincipals) {
assertTrue(principalMgr.hasPrincipal(pcpl.getName()));
}
}
@Test
- public void testGetPrincipal() {
- Principal p = principalMgr.getPrincipal(everyone.getName());
- assertEquals(everyone, p);
+ public void testHasPrincipalUnknown() {
+
assertFalse(principalMgr.hasPrincipal(TestPrincipalProvider.UNKNOWN.getName()));
+ }
- for (Principal pcpl : adminPrincipals) {
- Principal pp = principalMgr.getPrincipal(pcpl.getName());
- assertEquals("PrincipalManager.getPrincipal returned Principal
with different Name", pcpl.getName(), pp.getName());
- }
+ @Test
+ public void testGetPrincipalUnknown() {
+
assertNull(principalMgr.getPrincipal(TestPrincipalProvider.UNKNOWN.getName()));
}
@Test
- public void testGetPrincipalGetName() {
- for (Principal pcpl : adminPrincipals) {
- Principal pp = principalMgr.getPrincipal(pcpl.getName());
- assertEquals("PrincipalManager.getPrincipal returned Principal
with different Name", pcpl.getName(), pp.getName());
+ public void testGetPrincipal() {
+ for (Principal principal : testPrincipals){
+ Principal pp = principalMgr.getPrincipal(principal.getName());
+ assertNotNull(pp);
+ assertEquals("PrincipalManager.getPrincipal returned Principal
with different Name", principal.getName(), pp.getName());
+ assertEquals("PrincipalManager.getPrincipal returned different
Principal", principal, pp);
}
}
@Test
- public void testGetPrincipals() {
+ public void testGetPrincipalsNonGroup() {
+ Iterator<? extends Principal> expected =
provider.findPrincipals(PrincipalManager.SEARCH_TYPE_NOT_GROUP);
+ PrincipalIterator it =
principalMgr.getPrincipals(PrincipalManager.SEARCH_TYPE_NOT_GROUP);
+
+ assertIterator(expected, it);
+ }
+
+ @Test
+ public void testGetPrincipalsNonGroupContainsNoGroups() {
PrincipalIterator it =
principalMgr.getPrincipals(PrincipalManager.SEARCH_TYPE_NOT_GROUP);
while (it.hasNext()) {
Principal p = it.nextPrincipal();
@@ -157,7 +116,15 @@ public class PrincipalManagerTest extend
}
@Test
- public void testGetGroupPrincipals() {
+ public void testGetPrincipalsGroup() {
+ Iterator<? extends Principal> expected =
provider.findPrincipals(PrincipalManager.SEARCH_TYPE_GROUP);
+ PrincipalIterator it =
principalMgr.getPrincipals(PrincipalManager.SEARCH_TYPE_GROUP);
+
+ assertIterator(expected, it);
+ }
+
+ @Test
+ public void testGetPrincipalsGroupContainsGroups() {
PrincipalIterator it =
principalMgr.getPrincipals(PrincipalManager.SEARCH_TYPE_GROUP);
while (it.hasNext()) {
Principal p = it.nextPrincipal();
@@ -166,25 +133,18 @@ public class PrincipalManagerTest extend
}
@Test
- public void testGetAllPrincipals() {
+ public void testGetPrincipalsAll() {
+ Iterator<? extends Principal> expected =
provider.findPrincipals(PrincipalManager.SEARCH_TYPE_ALL);
PrincipalIterator it =
principalMgr.getPrincipals(PrincipalManager.SEARCH_TYPE_ALL);
- while (it.hasNext()) {
- Principal p = it.nextPrincipal();
- assertTrue(principalMgr.hasPrincipal(p.getName()));
- assertEquals(principalMgr.getPrincipal(p.getName()), p);
- }
+
+ assertIterator(expected, it);
}
@Test
- public void testMembers() {
- PrincipalIterator it =
principalMgr.getPrincipals(PrincipalManager.SEARCH_TYPE_ALL);
- while (it.hasNext()) {
- Principal p = it.nextPrincipal();
- if (p.equals(principalMgr.getEveryone())) {
- continue;
- }
+ public void testAllMembersKnown() {
+ for (Principal p : testPrincipals) {
if (isGroup(p)) {
- Enumeration<? extends Principal> en =
((java.security.acl.Group) p).members();
+ Enumeration<? extends Principal> en = ((Group) p).members();
while (en.hasMoreElements()) {
Principal memb = en.nextElement();
assertTrue(principalMgr.hasPrincipal(memb.getName()));
@@ -194,52 +154,32 @@ public class PrincipalManagerTest extend
}
@Test
- public void testMembers2() throws Exception {
- Authorizable gr = null;
- try {
- gr = ((JackrabbitSession)
superuser).getUserManager().createGroup(getClass().getName());
- superuser.save();
- PrincipalIterator it =
principalMgr.getPrincipals(PrincipalManager.SEARCH_TYPE_ALL);
- while (it.hasNext()) {
- Principal p = it.nextPrincipal();
- if (p.equals(principalMgr.getEveryone())) {
- continue;
- }
- if (isGroup(p)) {
- Enumeration<? extends Principal> en =
((java.security.acl.Group) p).members();
- while (en.hasMoreElements()) {
- Principal memb = en.nextElement();
- assertTrue(principalMgr.hasPrincipal(memb.getName()));
- }
- }
- }
- } finally {
- if (gr != null) {
- gr.remove();
- superuser.save();
- }
- }
+ public void testGroupMembershipNonGroup() {
+ assertMembership(principalMgr, PrincipalManager.SEARCH_TYPE_NOT_GROUP);
}
@Test
- public void testGroupMembership() {
- testMembership(PrincipalManager.SEARCH_TYPE_NOT_GROUP);
- testMembership(PrincipalManager.SEARCH_TYPE_GROUP);
- testMembership(PrincipalManager.SEARCH_TYPE_ALL);
+ public void testGroupMembershipGroup() {
+ assertMembership(principalMgr, PrincipalManager.SEARCH_TYPE_GROUP);
}
- private void testMembership(int searchType) {
- PrincipalIterator it = principalMgr.getPrincipals(searchType);
+ @Test
+ public void testGroupMembershipAll() {
+ assertMembership(principalMgr, PrincipalManager.SEARCH_TYPE_ALL);
+ }
+
+ private static void assertMembership(@Nonnull PrincipalManager mgr, int
searchType) {
+ PrincipalIterator it = mgr.getPrincipals(searchType);
while (it.hasNext()) {
Principal p = it.nextPrincipal();
- if (p.equals(everyone)) {
+ if (p.equals(EveryonePrincipal.getInstance())) {
continue;
}
boolean atleastEveryone = false;
- for (PrincipalIterator membership =
principalMgr.getGroupMembership(p); membership.hasNext();) {
+ for (PrincipalIterator membership = mgr.getGroupMembership(p);
membership.hasNext();) {
Principal gr = membership.nextPrincipal();
assertTrue(isGroup(gr));
- if (gr.equals(everyone)) {
+ if (gr.equals(EveryonePrincipal.getInstance())) {
atleastEveryone = true;
}
}
@@ -248,15 +188,13 @@ public class PrincipalManagerTest extend
}
@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.");
- }
- }
+ public void testGetGroupMembershipEveryoneEmpty() {
+
assertFalse(principalMgr.getGroupMembership(EveryonePrincipal.getInstance()).hasNext());
+ }
+
+ @Test
+ public void testGetGroupMembershipEveryoneWithoutEveryone() {
+
assertFalse(Iterators.contains(principalMgr.getGroupMembership(EveryonePrincipal.getInstance()),
EveryonePrincipal.getInstance()));
}
@Test
@@ -271,7 +209,7 @@ public class PrincipalManagerTest extend
assertTrue(isGroup(p));
- Enumeration<? extends Principal> members =
((java.security.acl.Group) p).members();
+ Enumeration<? extends Principal> members = ((Group) p).members();
while (members.hasMoreElements()) {
Principal memb = members.nextElement();
@@ -290,111 +228,84 @@ public class PrincipalManagerTest extend
@Test
public void testFindPrincipal() {
- for (Principal pcpl : adminPrincipals) {
- if (pcpl.equals(everyone)) {
- continue;
- }
-
- assertTrue(principalMgr.hasPrincipal(pcpl.getName()));
+ for (Principal pcpl : testPrincipals) {
PrincipalIterator it = principalMgr.findPrincipals(pcpl.getName());
- // search must find at least a single principal
- assertTrue("findPrincipals does not find principal with filter '"
+ pcpl.getName() + '\'', it.hasNext());
+ assertTrue("findPrincipals does not find principal with filter '"
+ pcpl.getName() + '\'', Iterators.contains(it, pcpl));
}
}
@Test
- public void testFindPrincipalByType() {
- for (Principal pcpl : adminPrincipals) {
- if (pcpl.equals(everyone)) {
- // special case covered by another test
- continue;
+ public void testFindPrincipalByTypeGroup() {
+ for (Principal pcpl : testPrincipals) {
+ if (isGroup(pcpl)) {
+ PrincipalIterator it =
principalMgr.findPrincipals(pcpl.getName(), PrincipalManager.SEARCH_TYPE_GROUP);
+ assertTrue("findPrincipals does not find principal with filter
'" + pcpl.getName() + '\'', Iterators.contains(it, pcpl));
+ } else {
+ PrincipalIterator it =
principalMgr.findPrincipals(pcpl.getName(),
PrincipalManager.SEARCH_TYPE_NOT_GROUP);
+ assertTrue("findPrincipals does not find principal with filter
'" + pcpl.getName() + '\'', Iterators.contains(it, pcpl));
}
+ }
+ }
- assertTrue(principalMgr.hasPrincipal(pcpl.getName()));
+ @Test
+ public void testFindPrincipalByType() {
+ for (Principal pcpl : testPrincipals) {
if (isGroup(pcpl)) {
- PrincipalIterator it =
principalMgr.findPrincipals(pcpl.getName(),
- PrincipalManager.SEARCH_TYPE_GROUP);
- // search must find at least a single matching group principal
- assertTrue("findPrincipals does not find principal with filter
" + pcpl.getName(), it.hasNext());
+ PrincipalIterator it =
principalMgr.findPrincipals(pcpl.getName(), PrincipalManager.SEARCH_TYPE_GROUP);
+ assertTrue("findPrincipals does not find principal with filter
'" + pcpl.getName() + '\'', Iterators.contains(it, pcpl));
} else {
- PrincipalIterator it =
principalMgr.findPrincipals(pcpl.getName(),
- PrincipalManager.SEARCH_TYPE_NOT_GROUP);
- // search must find at least a single matching non-group
principal
- assertTrue("findPrincipals does not find principal with filter
'" + pcpl.getName() + "' and type " + PrincipalManager.SEARCH_TYPE_NOT_GROUP,
it.hasNext());
+ PrincipalIterator it =
principalMgr.findPrincipals(pcpl.getName(),
PrincipalManager.SEARCH_TYPE_NOT_GROUP);
+ assertTrue("findPrincipals does not find principal with filter
'" + pcpl.getName() + '\'', Iterators.contains(it, pcpl));
}
}
}
@Test
public void testFindPrincipalByTypeAll() {
- for (Principal pcpl : adminPrincipals) {
- if (pcpl.equals(everyone)) {
- // special case covered by another test
- continue;
- }
-
- assertTrue(principalMgr.hasPrincipal(pcpl.getName()));
-
+ for (Principal pcpl : testPrincipals) {
PrincipalIterator it = principalMgr.findPrincipals(pcpl.getName(),
PrincipalManager.SEARCH_TYPE_ALL);
- PrincipalIterator it2 =
principalMgr.findPrincipals(pcpl.getName());
-
- assertTrue("Principal "+ pcpl.getName() + " not found",
it.hasNext());
- assertTrue("Principal "+ pcpl.getName() + " not found",
it2.hasNext());
-
- // both search must reveal the same result and size
- assertTrue(it.getSize() == it2.getSize());
-
- Set<Principal> s1 = new HashSet<Principal>();
- Set<Principal> s2 = new HashSet<Principal>();
- while (it.hasNext() && it2.hasNext()) {
- s1.add(it.nextPrincipal());
- s2.add(it2.nextPrincipal());
- }
-
- assertEquals(s1, s2);
- assertFalse(it.hasNext() && it2.hasNext());
+ assertTrue("findPrincipals does not find principal with filter '"
+ pcpl.getName() + '\'', Iterators.contains(it, pcpl));
}
}
@Test
public void testFindEveryone() {
- Principal everyone = principalMgr.getEveryone();
- assertTrue(principalMgr.hasPrincipal(everyone.getName()));
-
- boolean containedInResult = false;
-
// untyped search -> everyone must be part of the result set
- PrincipalIterator it = principalMgr.findPrincipals(everyone.getName());
- while (it.hasNext()) {
- Principal p = it.nextPrincipal();
- if (p.getName().equals(everyone.getName())) {
- containedInResult = true;
- }
- }
- assertTrue(containedInResult);
+ PrincipalIterator it =
principalMgr.findPrincipals(EveryonePrincipal.NAME);
+ assertTrue("findPrincipals does not find principal with filter '" +
EveryonePrincipal.NAME + '\'', Iterators.contains(it,
EveryonePrincipal.getInstance()));
+ }
+ @Test
+ public void testFindEveryoneTypeGroup() {
// search group only -> everyone must be part of the result set
- containedInResult = false;
- it = principalMgr.findPrincipals(everyone.getName(),
PrincipalManager.SEARCH_TYPE_GROUP);
- while (it.hasNext()) {
- Principal p = it.nextPrincipal();
- if (p.getName().equals(everyone.getName())) {
- containedInResult = true;
- }
- }
- assertTrue(containedInResult);
+ PrincipalIterator it =
principalMgr.findPrincipals(EveryonePrincipal.NAME,
PrincipalManager.SEARCH_TYPE_GROUP);
+ assertTrue("findPrincipals does not find principal with filter '" +
EveryonePrincipal.NAME + '\'', Iterators.contains(it,
EveryonePrincipal.getInstance()));
+ }
+ @Test
+ public void testFindEveryoneTypeNonGroup() {
// search non-group only -> everyone should not be part of the result
set
- containedInResult = false;
- it = principalMgr.findPrincipals(everyone.getName(),
PrincipalManager.SEARCH_TYPE_NOT_GROUP);
- while (it.hasNext()) {
- Principal p = it.nextPrincipal();
- if (p.getName().equals(everyone.getName())) {
- containedInResult = true;
- }
- }
- assertFalse(containedInResult);
+ PrincipalIterator it =
principalMgr.findPrincipals(EveryonePrincipal.NAME,
PrincipalManager.SEARCH_TYPE_NOT_GROUP);
+ assertFalse("findPrincipals did find principal with filter '" +
EveryonePrincipal.NAME + '\'', Iterators.contains(it,
EveryonePrincipal.getInstance()));
+ }
+
+ @Test
+ public void testFindUnknownByTypeAll() {
+ String unknownHint =
TestPrincipalProvider.UNKNOWN.getName().substring(0, 4);
+ assertFalse(principalMgr.findPrincipals(unknownHint,
PrincipalManager.SEARCH_TYPE_ALL).hasNext());
+ }
+
+ @Test
+ public void testFindUnknownByTypeGroup() {
+ String unknownHint =
TestPrincipalProvider.UNKNOWN.getName().substring(0, 4);
+ assertFalse(principalMgr.findPrincipals(unknownHint,
PrincipalManager.SEARCH_TYPE_GROUP).hasNext());
+ }
+
+ @Test
+ public void testFindUnknownByTypeNotGroup() {
+ String unknownHint =
TestPrincipalProvider.UNKNOWN.getName().substring(0, 4);
+ assertFalse(principalMgr.findPrincipals(unknownHint,
PrincipalManager.SEARCH_TYPE_NOT_GROUP).hasNext());
}
}
\ No newline at end of file
Added:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/SystemPrincipalTest.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/SystemPrincipalTest.java?rev=1784743&view=auto
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/SystemPrincipalTest.java
(added)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/SystemPrincipalTest.java
Tue Feb 28 14:31:55 2017
@@ -0,0 +1,93 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.jackrabbit.oak.spi.security.principal;
+
+import java.security.Principal;
+
+import org.apache.jackrabbit.api.security.principal.JackrabbitPrincipal;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+public class SystemPrincipalTest {
+
+ @Test
+ public void testGetName() {
+ assertEquals("system", SystemPrincipal.INSTANCE.getName());
+ }
+
+ @Test
+ public void testEquals() {
+ assertEquals(SystemPrincipal.INSTANCE, SystemPrincipal.INSTANCE);
+ }
+
+ @Test
+ public void testSame() {
+ assertSame(SystemPrincipal.INSTANCE, SystemPrincipal.INSTANCE);
+ }
+
+ @Test
+ public void testHashCode() {
+ assertTrue(SystemPrincipal.INSTANCE.hashCode() ==
SystemPrincipal.INSTANCE.hashCode());
+ }
+
+ @Test
+ public void testNotEqualsOtherPrincipalWithSameName() {
+ Principal another = new Principal() {
+ public String getName() {
+ return SystemPrincipal.INSTANCE.getName();
+ }
+ };
+ assertFalse(SystemPrincipal.INSTANCE.equals(another));
+ }
+
+ @Test
+ public void testEqualsOtherJackrabbitPrincipal() {
+ Principal another = new OtherSystem();
+ assertFalse(SystemPrincipal.INSTANCE.equals(another));
+ }
+
+ @Test
+ public void testToString() {
+ assertNotNull(SystemPrincipal.INSTANCE.toString());
+ assertNotEquals(SystemPrincipal.INSTANCE.getName(),
SystemPrincipal.INSTANCE.toString());
+ }
+
+
//--------------------------------------------------------------------------
+
+ private class OtherSystem implements JackrabbitPrincipal {
+ public String getName() {
+ return SystemPrincipal.INSTANCE.getName();
+ }
+ @Override
+ public boolean equals(Object o) {
+ if (o instanceof JackrabbitPrincipal) {
+ return getName().equals(((JackrabbitPrincipal) o).getName());
+ }
+ return false;
+ }
+ @Override
+ public int hashCode() {
+ return getName().hashCode();
+ }
+ }
+}
\ No newline at end of file
Added:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/TestPrincipalProvider.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/TestPrincipalProvider.java?rev=1784743&view=auto
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/TestPrincipalProvider.java
(added)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/spi/security/principal/TestPrincipalProvider.java
Tue Feb 28 14:31:55 2017
@@ -0,0 +1,228 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.jackrabbit.oak.spi.security.principal;
+
+import java.security.Principal;
+import java.security.acl.Group;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import com.google.common.base.Function;
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Iterators;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import org.apache.jackrabbit.api.security.principal.PrincipalManager;
+
+public final class TestPrincipalProvider implements PrincipalProvider {
+
+ public static final Principal UNKNOWN = new PrincipalImpl("unknown");
+
+ private final boolean exposesEveryone;
+ private final Map<String, Principal> principals;
+
+ public TestPrincipalProvider() {
+ this(true);
+ }
+
+ public TestPrincipalProvider(boolean exposesEveryone) {
+ this.exposesEveryone = exposesEveryone;
+ this.principals = TestPrincipals.asMap();
+ }
+
+ public TestPrincipalProvider(String... principalNames) {
+ this.exposesEveryone = true;
+ this.principals = Maps.toMap(ImmutableSet.copyOf(principalNames), new
Function<String, Principal>() {
+ @Override
+ public Principal apply(String input) {
+ return new PrincipalImpl(input);
+ }
+ });
+ }
+
+ public Iterable<Principal> getTestPrincipals() {
+ return principals.values();
+ }
+
+ public Iterable<Principal> all() {
+ Set all = Sets.newHashSet(principals.values());
+ all.add(EveryonePrincipal.getInstance());
+ return all;
+ }
+
+ public static String getIDFromPrincipal(@Nonnull Principal principal) {
+ return principal.getName() + "_id";
+ }
+
+ @CheckForNull
+ private static String getPrincipalNameFromID(@Nonnull String id) {
+ if (id.endsWith("_id")) {
+ return id.substring(0, id.lastIndexOf("_id"));
+ } else {
+ return null;
+ }
+ }
+
+ @CheckForNull
+ @Override
+ public Principal getPrincipal(@Nonnull String principalName) {
+ if (exposesEveryone && EveryonePrincipal.NAME.equals(principalName)) {
+ return EveryonePrincipal.getInstance();
+ } else {
+ return principals.get(principalName);
+ }
+ }
+
+ @Nonnull
+ @Override
+ public Set<Group> getGroupMembership(@Nonnull Principal principal) {
+ if (principals.equals(TestPrincipals.asMap())) {
+ return TestPrincipals.membership(principal.getName());
+ } else if (principals.values().contains(principal)) {
+ return ImmutableSet.<Group>of(EveryonePrincipal.getInstance());
+ } else {
+ return ImmutableSet.of();
+ }
+ }
+
+ @Nonnull
+ @Override
+ public Set<? extends Principal> getPrincipals(@Nonnull String userID) {
+ String pName = getPrincipalNameFromID(userID);
+ if (pName != null) {
+ Principal p = principals.get(pName);
+ if (p != null) {
+ Set s = Sets.newHashSet(p);
+ s.addAll(getGroupMembership(p));
+ return s;
+ }
+ }
+
+ return ImmutableSet.of();
+ }
+
+ @Nonnull
+ @Override
+ public Iterator<? extends Principal> findPrincipals(@Nullable String
nameHint, int searchType) {
+ return Iterables.filter(all(), new SearchTypePredicate(nameHint,
searchType)).iterator();
+ }
+
+ @Nonnull
+ @Override
+ public Iterator<? extends Principal> findPrincipals(int searchType) {
+ return findPrincipals(null, searchType);
+ }
+
+ private static final class SearchTypePredicate implements
Predicate<Principal> {
+
+ private final int searchType;
+ private final String nameHint;
+
+ private SearchTypePredicate(@Nullable String nameHint, int searchType)
{
+ this.searchType = searchType;
+ this.nameHint = nameHint;
+ }
+
+ @Override
+ public boolean apply(Principal principal) {
+ if (nameHint != null && principal != null &&
!principal.getName().startsWith(nameHint)) {
+ return false;
+ }
+
+ switch (searchType) {
+ case PrincipalManager.SEARCH_TYPE_ALL: return true;
+ case PrincipalManager.SEARCH_TYPE_GROUP: return principal
instanceof Group;
+ case PrincipalManager.SEARCH_TYPE_NOT_GROUP: return
!(principal instanceof Group);
+ default: throw new IllegalArgumentException();
+ }
+ }
+ }
+
+ private static final class TestGroup extends PrincipalImpl implements
Group {
+
+ private final Enumeration<? extends Principal> members;
+
+ public TestGroup(String name, Principal... members) {
+ super(name);
+ Set<? extends Principal> mset = ImmutableSet.copyOf(members);
+ this.members = Iterators.asEnumeration(mset.iterator());
+ }
+
+ @Override
+ public boolean addMember(Principal user) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public boolean removeMember(Principal user) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public boolean isMember(Principal member) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Enumeration<? extends Principal> members() {
+ return members;
+ }
+ }
+
+ private static final class TestPrincipals {
+
+ private static final Principal a = new PrincipalImpl("a");
+ private static final Principal ac = new PrincipalImpl("ac");
+ private static final Group gr1 = new TestGroup("tGr1");
+ private static final Group gr2 = new TestGroup("tGr2", a);
+ private static final Group gr3 = new TestGroup("gr2", gr2, ac);
+
+ private static final Map<String, Principal> principals =
ImmutableMap.<String, Principal>builder()
+ .put(a.getName(), a)
+ .put("b", new PrincipalImpl("b"))
+ .put(ac.getName(), ac)
+ .put(gr1.getName(), gr1)
+ .put(gr2.getName(), gr2)
+ .put(gr3.getName(), gr3).build();
+
+ private static Map<String, Principal> asMap() {
+ return principals;
+ }
+
+ private static Set<Group> membership(@Nonnull String name) {
+ if ("a".equals(name)) {
+ return ImmutableSet.of(EveryonePrincipal.getInstance(), gr2,
gr3);
+ } else if ("ac".equals(name)) {
+ return ImmutableSet.of(EveryonePrincipal.getInstance(), gr3);
+ } else if (gr2.getName().equals(name)) {
+ return ImmutableSet.of(EveryonePrincipal.getInstance(), gr3);
+ } else if (principals.containsKey(name)) {
+ return ImmutableSet.<Group>of(EveryonePrincipal.getInstance());
+ } else {
+ return ImmutableSet.of();
+ }
+ }
+ }
+}
\ No newline at end of file
