Author: angela
Date: Thu Jun 1 15:27:50 2017
New Revision: 1797233
URL: http://svn.apache.org/viewvc?rev=1797233&view=rev
Log:
OAK-5882 : Improve coverage for oak.security code in oak-core (wip)
Modified:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/internal/SecurityProviderRegistrationTest.java
Modified:
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/internal/SecurityProviderRegistrationTest.java
URL:
http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/internal/SecurityProviderRegistrationTest.java?rev=1797233&r1=1797232&r2=1797233&view=diff
==============================================================================
---
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/internal/SecurityProviderRegistrationTest.java
(original)
+++
jackrabbit/oak/trunk/oak-core/src/test/java/org/apache/jackrabbit/oak/security/internal/SecurityProviderRegistrationTest.java
Thu Jun 1 15:27:50 2017
@@ -17,51 +17,64 @@
package org.apache.jackrabbit.oak.security.internal;
import java.lang.reflect.Field;
-import java.security.Principal;
import java.util.List;
import java.util.Map;
-import java.util.Set;
import javax.annotation.Nonnull;
-import javax.jcr.security.AccessControlManager;
+import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableMap;
-import org.apache.jackrabbit.api.security.principal.PrincipalManager;
+import com.google.common.collect.Iterables;
import org.apache.jackrabbit.oak.AbstractSecurityTest;
import org.apache.jackrabbit.oak.api.PropertyState;
-import org.apache.jackrabbit.oak.api.Root;
import org.apache.jackrabbit.oak.api.Tree;
-import org.apache.jackrabbit.oak.namepath.NamePathMapper;
import org.apache.jackrabbit.oak.plugins.memory.PropertyStates;
import org.apache.jackrabbit.oak.plugins.tree.TreeLocation;
import
org.apache.jackrabbit.oak.security.authorization.AuthorizationConfigurationImpl;
import
org.apache.jackrabbit.oak.security.authorization.composite.CompositeAuthorizationConfiguration;
+import
org.apache.jackrabbit.oak.security.authorization.restriction.WhiteboardRestrictionProvider;
import org.apache.jackrabbit.oak.security.principal.PrincipalConfigurationImpl;
import org.apache.jackrabbit.oak.spi.security.CompositeConfiguration;
-import org.apache.jackrabbit.oak.spi.security.ConfigurationBase;
import org.apache.jackrabbit.oak.spi.security.ConfigurationParameters;
import org.apache.jackrabbit.oak.spi.security.Context;
+import org.apache.jackrabbit.oak.spi.security.SecurityConfiguration;
+import org.apache.jackrabbit.oak.spi.security.SecurityProvider;
+import
org.apache.jackrabbit.oak.spi.security.authentication.AuthenticationConfiguration;
+import
org.apache.jackrabbit.oak.spi.security.authentication.token.CompositeTokenConfiguration;
+import
org.apache.jackrabbit.oak.spi.security.authentication.token.TokenConfiguration;
import
org.apache.jackrabbit.oak.spi.security.authorization.AuthorizationConfiguration;
-import
org.apache.jackrabbit.oak.spi.security.authorization.permission.PermissionProvider;
import
org.apache.jackrabbit.oak.spi.security.authorization.restriction.RestrictionProvider;
import
org.apache.jackrabbit.oak.spi.security.principal.CompositePrincipalConfiguration;
import org.apache.jackrabbit.oak.spi.security.principal.PrincipalConfiguration;
-import org.apache.jackrabbit.oak.spi.security.principal.PrincipalProvider;
+import org.apache.jackrabbit.oak.spi.security.privilege.PrivilegeConfiguration;
+import org.apache.jackrabbit.oak.spi.security.user.AuthorizableNodeName;
+import org.apache.jackrabbit.oak.spi.security.user.UserAuthenticationFactory;
+import org.apache.jackrabbit.oak.spi.security.user.UserConfiguration;
+import
org.apache.jackrabbit.oak.spi.security.user.action.AuthorizableActionProvider;
+import org.apache.sling.testing.mock.osgi.junit.OsgiContext;
+import org.junit.Rule;
import org.junit.Test;
+import org.mockito.Mockito;
import org.osgi.framework.Constants;
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;
+import static org.mockito.Mockito.when;
public class SecurityProviderRegistrationTest extends AbstractSecurityTest {
private static final Map<String, Object> PROPS = ImmutableMap.<String,
Object>of("prop", "val");
+ @Rule
+ public final OsgiContext context = new OsgiContext();
+
private SecurityProviderRegistration registration = new
SecurityProviderRegistration();
private static void assertContext(@Nonnull Context context, int
expectedSize, @Nonnull Tree tree, boolean isDefined) throws Exception {
- Class c = context.getClass();
+ Class<?> c = context.getClass();
assertTrue(c.getName().endsWith("CompositeContext"));
Field f = c.getDeclaredField("delegatees");
@@ -79,19 +92,349 @@ public class SecurityProviderRegistratio
assertEquals(isDefined,
context.definesLocation(TreeLocation.create(tree)));
}
+ private static <T> T mockConfiguration(Class<? extends
SecurityConfiguration> cl) {
+ SecurityConfiguration sc = Mockito.mock(cl);
+ when(sc.getContext()).thenReturn(new ContextImpl());
+ when(sc.getParameters()).thenReturn(ConfigurationParameters.EMPTY);
+ return (T) sc;
+ }
+
+ private static Map<String, Object> requiredServiceIdMap(@Nonnull String...
ids) {
+ return ImmutableMap.of("requiredServicePids", ids);
+ }
+
+ @Test
+ public void testActivateWithRequiredId() {
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("serviceId"));
+
+ SecurityProvider service = context.getService(SecurityProvider.class);
+ assertNull(service);
+
+
registration.bindAuthorizableNodeName(Mockito.mock(AuthorizableNodeName.class),
ImmutableMap.of(Constants.SERVICE_PID, "serviceId"));
+
+ service = context.getService(SecurityProvider.class);
+ assertNotNull(service);
+ }
+
+ @Test
+ public void testActivate() {
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("serviceA", "serviceB"));
+
+ SecurityProvider service = context.getService(SecurityProvider.class);
+ assertNull(service);
+
+ RestrictionProvider mockRp = Mockito.mock(RestrictionProvider.class);
+ registration.bindRestrictionProvider(mockRp,
ImmutableMap.of(Constants.SERVICE_PID, "serviceA"));
+
+ service = context.getService(SecurityProvider.class);
+ assertNull(service);
+
+ registration.bindAuthorizationConfiguration(new
AuthorizationConfigurationImpl(), ImmutableMap.of(Constants.SERVICE_PID,
"serviceB"));
+ service = context.getService(SecurityProvider.class);
+ assertNotNull(service);
+ }
+
+ @Test
+ public void testActivateAddsPrecondition() throws Exception {
+ Field f = registration.getClass().getDeclaredField("preconditions");
+ f.setAccessible(true);
+
+ assertTrue(((Preconditions) f.get(registration)).areSatisfied());
+
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("requiredService"));
+
+ assertFalse(((Preconditions) f.get(registration)).areSatisfied());
+ }
+
+ @Test
+ public void testActivateWithoutPreconditions() {
+ registration.activate(context.bundleContext(), requiredServiceIdMap());
+
+ SecurityProvider service = context.getService(SecurityProvider.class);
+ assertNotNull(service);
+ assertEquals(3,
Iterables.size(Iterables.filter(service.getConfigurations(),
Predicates.notNull())));
+ }
+
+ @Test
+ public void testModified() {
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("rpId", "authorizationId"));
+
+ registration.bindAuthorizationConfiguration(new
AuthorizationConfigurationImpl(), ImmutableMap.of(Constants.SERVICE_PID,
"authorizationId"));
+
+ assertNull(context.getService(SecurityProvider.class));
+
+ // modify requiredServiceIds by removing the rpId from the mandatory
services
+ // => should re-register the security provider
+ registration.modified(requiredServiceIdMap("authorizationId"));
+
+ SecurityProvider service = context.getService(SecurityProvider.class);
+ assertNotNull(service);
+
+ RestrictionProvider rp =
service.getConfiguration(AuthorizationConfiguration.class).getRestrictionProvider();
+ assertTrue(rp instanceof WhiteboardRestrictionProvider);
+ }
+
+ @Test
+ public void testModifiedPreconditionStillSatisfied() {
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("rpId", "authorizationId"));
+
+ RestrictionProvider mockRp = Mockito.mock(RestrictionProvider.class);
+ registration.bindRestrictionProvider(mockRp,
ImmutableMap.of(Constants.SERVICE_PID, "rpId"));
+ registration.bindAuthorizationConfiguration(new
AuthorizationConfigurationImpl(), ImmutableMap.of(Constants.SERVICE_PID,
"authorizationId"));
+
+ SecurityProvider service = context.getService(SecurityProvider.class);
+ assertNotNull(service);
+
+ registration.modified(requiredServiceIdMap("authorizationId"));
+
+ SecurityProvider service2 = context.getService(SecurityProvider.class);
+ assertSame(service, service2);
+ }
+
+ @Test
+ public void testDeactivate() throws Exception {
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("nodeName"));
+ AuthorizableNodeName mock = Mockito.mock(AuthorizableNodeName.class);
+ registration.bindAuthorizableNodeName(mock,
ImmutableMap.of(Constants.SERVICE_PID, "nodeName"));
+
+ SecurityProvider service = context.getService(SecurityProvider.class);
+ assertNotNull(service);
+
+ registration.deactivate();
+
+ // provider must have been unregistered
+ assertNull(context.getService(SecurityProvider.class));
+ }
+
+ @Test
+ public void testDeactivateWithoutPreconditions() throws Exception {
+ registration.activate(context.bundleContext(), requiredServiceIdMap());
+ UserAuthenticationFactory mock =
Mockito.mock(UserAuthenticationFactory.class);
+ registration.bindUserAuthenticationFactory(mock,
ImmutableMap.of(Constants.SERVICE_PID, "nodeName"));
+
+ assertNotNull(context.getService(SecurityProvider.class));
+
+ registration.deactivate();
+
+ // securityprovider must have been unregistered
+ assertNull(context.getService(SecurityProvider.class));
+ }
+
+ @Test
+ public void testDeactivateClearsPreconditions() throws Exception {
+ Field f = registration.getClass().getDeclaredField("preconditions");
+ f.setAccessible(true);
+
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("nodeName"));
+
+ assertFalse(((Preconditions) f.get(registration)).areSatisfied());
+
+ AuthorizableNodeName mock = Mockito.mock(AuthorizableNodeName.class);
+ registration.bindAuthorizableNodeName(mock,
ImmutableMap.of(Constants.SERVICE_PID, "nodeName"));
+
+ assertTrue(((Preconditions) f.get(registration)).areSatisfied());
+
+ registration.deactivate();
+
+ assertTrue(((Preconditions) f.get(registration)).areSatisfied());
+ }
+
+ @Test
+ public void testBindOptionalCandidate() throws Exception {
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("serviceId"));
+
+ Field f = registration.getClass().getDeclaredField("preconditions");
+ f.setAccessible(true);
+
+ TokenConfiguration tc = mockConfiguration(TokenConfiguration.class);
+ registration.bindTokenConfiguration(tc,
ImmutableMap.of(Constants.SERVICE_PID, "otherServiceId"));
+
+ Preconditions preconditions = (Preconditions) f.get(registration);
+ assertFalse(preconditions.areSatisfied());
+
+ assertNull(context.getService(SecurityProvider.class));
+ }
+
+ @Test
+ public void testBindOptionalCandidateAfterRegistration() {
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("serviceId"));
+
+
registration.bindTokenConfiguration(mockConfiguration(TokenConfiguration.class),
ImmutableMap.of(Constants.SERVICE_PID, "serviceId"));
+
+ SecurityProvider service = context.getService(SecurityProvider.class);
+ assertNotNull(service);
+
+ // binding another (optional configuration) must not result in
re-registration of the service
+
registration.bindPrincipalConfiguration(mockConfiguration(PrincipalConfiguration.class),
ImmutableMap.of(Constants.SERVICE_PID, "optionalService"));
+
+ SecurityProvider service2 = context.getService(SecurityProvider.class);
+ assertSame(service, service2);
+ }
+
+ @Test
+ public void testBindMandatoryCandidate() throws Exception {
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("serviceId"));
+
+ Field f = registration.getClass().getDeclaredField("preconditions");
+ f.setAccessible(true);
+
+ TokenConfiguration tc = mockConfiguration(TokenConfiguration.class);
+ registration.bindTokenConfiguration(tc,
ImmutableMap.of(Constants.SERVICE_PID, "serviceId"));
+
+ Preconditions preconditions = (Preconditions) f.get(registration);
+ assertTrue(preconditions.areSatisfied());
+
+ assertNotNull(context.getService(SecurityProvider.class));
+ }
+
+ @Test
+ public void testUnbindMandatoryCandidate() {
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("actionProvider"));
+
+
registration.bindUserConfiguration(mockConfiguration(UserConfiguration.class));
+
+ AuthorizableActionProvider ap =
Mockito.mock(AuthorizableActionProvider.class);
+ registration.bindAuthorizableActionProvider(ap,
ImmutableMap.of(Constants.SERVICE_PID, "actionProvider"));
+
+ SecurityProvider service = context.getService(SecurityProvider.class);
+ assertNotNull(service);
+
+ registration.unbindAuthorizableActionProvider(ap,
ImmutableMap.of(Constants.SERVICE_PID, "actionProvider"));
+ service = context.getService(SecurityProvider.class);
+ assertNull(service);
+ }
+
+ @Test
+ public void testUnbindMandatoryCandidateOnPreconditions() throws Exception
{
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("nodeName"));
+
+ Field f = registration.getClass().getDeclaredField("preconditions");
+ f.setAccessible(true);
+
+ AuthorizableNodeName mock = Mockito.mock(AuthorizableNodeName.class);
+ registration.bindAuthorizableNodeName(mock,
ImmutableMap.of(Constants.SERVICE_PID, "nodeName"));
+ registration.unbindAuthorizableNodeName(mock,
ImmutableMap.of(Constants.SERVICE_PID, "nodeName"));
+
+ Preconditions preconditions = (Preconditions) f.get(registration);
+ assertFalse(preconditions.areSatisfied());
+ }
+
+ @Test
+ public void testUnbindOptionalCandidateAfterRegistration() {
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("serviceId"));
+
+ UserAuthenticationFactory uaf =
Mockito.mock(UserAuthenticationFactory.class);
+ Map<String, Object> properties =
ImmutableMap.of(Constants.SERVICE_PID, "notMandatory");
+ registration.bindUserAuthenticationFactory(uaf, properties);
+
+ assertNull(context.getService(SecurityProvider.class));
+
+
registration.bindAuthorizableActionProvider(Mockito.mock(AuthorizableActionProvider.class),
ImmutableMap.of(Constants.SERVICE_PID, "serviceId"));
+
+ SecurityProvider service = context.getService(SecurityProvider.class);
+ assertNotNull(service);
+
+ // unbinding an optional configuration must not result in
unrregistration of the service
+ registration.unbindUserAuthenticationFactory(uaf, properties);
+
+ SecurityProvider service2 = context.getService(SecurityProvider.class);
+ assertSame(service, service2);
+ }
+
+ @Test
+ public void testBindUnbindAuthenticationConfiguration() throws Exception {
+ Field f =
registration.getClass().getDeclaredField("authenticationConfiguration");
+ f.setAccessible(true);
+
+ assertNull(f.get(registration));
+
+ AuthenticationConfiguration ac =
mockConfiguration(AuthenticationConfiguration.class);
+ registration.bindAuthenticationConfiguration(ac);
+
+ assertSame(ac, f.get(registration));
+
+ registration.unbindAuthenticationConfiguration(ac);
+ assertNull(f.get(registration));
+ }
+
+ @Test
+ public void testBindAnotherAuthenticationConfiguration() throws Exception {
+ Field f =
registration.getClass().getDeclaredField("authenticationConfiguration");
+ f.setAccessible(true);
+
+ AuthenticationConfiguration ac =
mockConfiguration(AuthenticationConfiguration.class);
+ registration.bindAuthenticationConfiguration(ac);
+ assertSame(ac, f.get(registration));
+
+ AuthenticationConfiguration ac2 =
mockConfiguration(AuthenticationConfiguration.class);
+ registration.bindAuthenticationConfiguration(ac2);
+ assertSame(ac2, f.get(registration));
+ }
+
+ @Test
+ public void testBindUnbindPrivilegeConfiguration() throws Exception {
+ Field f =
registration.getClass().getDeclaredField("privilegeConfiguration");
+ f.setAccessible(true);
+
+ assertNull(f.get(registration));
+
+ PrivilegeConfiguration pc =
mockConfiguration(PrivilegeConfiguration.class);
+ registration.bindPrivilegeConfiguration(pc);
+
+ assertSame(pc, f.get(registration));
+
+ registration.unbindPrivilegeConfiguration(pc);
+ assertNull(f.get(registration));
+ }
+
+ @Test
+ public void testBindUnbindUserConfiguration() throws Exception {
+ Field f =
registration.getClass().getDeclaredField("userConfiguration");
+ f.setAccessible(true);
+
+ assertNull(f.get(registration));
+
+ UserConfiguration uc = mockConfiguration(UserConfiguration.class);
+ registration.bindUserConfiguration(uc);
+
+ assertSame(uc, f.get(registration));
+
+ registration.unbindUserConfiguration(uc);
+ assertNull(f.get(registration));
+ }
+
+ @Test
+ public void testBindUnbindTokenConfiguration() throws Exception {
+ Field f =
registration.getClass().getDeclaredField("tokenConfiguration");
+ f.setAccessible(true);
+
+ assertTrue(f.get(registration) instanceof CompositeTokenConfiguration);
+
+ TokenConfiguration tc = mockConfiguration(TokenConfiguration.class);
+ registration.bindTokenConfiguration(tc, PROPS);
+
+ CompositeTokenConfiguration composite = (CompositeTokenConfiguration)
f.get(registration);
+ assertEquals(1, composite.getConfigurations().size());
+ assertTrue(composite.getConfigurations().contains(tc));
+
+ registration.unbindTokenConfiguration(tc, PROPS);
+ composite = (CompositeTokenConfiguration) f.get(registration);
+ assertTrue(composite.getConfigurations().isEmpty());
+ }
+
@Test
public void testAuthorizationRanking() throws Exception {
Field f =
registration.getClass().getDeclaredField("authorizationConfiguration");
f.setAccessible(true);
- AuthorizationConfiguration testAc = new
TestAuthorizationConfiguration();
+ AuthorizationConfiguration testAc =
mockConfiguration(AuthorizationConfiguration.class);
registration.bindAuthorizationConfiguration(testAc,
ConfigurationParameters.EMPTY);
AuthorizationConfigurationImpl ac = new
AuthorizationConfigurationImpl();
ac.setParameters(ConfigurationParameters.of(CompositeConfiguration.PARAM_RANKING,
500));
registration.bindAuthorizationConfiguration(ac, PROPS);
- AuthorizationConfiguration testAc2 = new
TestAuthorizationConfiguration();
+ AuthorizationConfiguration testAc2 =
mockConfiguration(AuthorizationConfiguration.class);
Map<String, Object> props = ImmutableMap.<String,
Object>of(Constants.SERVICE_RANKING, new Integer(100));
registration.bindAuthorizationConfiguration(testAc2, props);
@@ -118,13 +461,13 @@ public class SecurityProviderRegistratio
Context ctx = cac.getContext();
assertContext(ctx, 1, t, false);
- AuthorizationConfiguration ac1 = new TestAuthorizationConfiguration();
+ AuthorizationConfiguration ac1 =
mockConfiguration(AuthorizationConfiguration.class);
registration.bindAuthorizationConfiguration(ac1, PROPS);
cac = (CompositeAuthorizationConfiguration) f.get(registration);
ctx = cac.getContext();
assertContext(ctx, 2, t, true);
- AuthorizationConfiguration ac2 = new TestAuthorizationConfiguration();
+ AuthorizationConfiguration ac2 =
mockConfiguration(AuthorizationConfiguration.class);
registration.bindAuthorizationConfiguration(ac2, PROPS);
cac = (CompositeAuthorizationConfiguration) f.get(registration);
ctx = cac.getContext();
@@ -162,14 +505,14 @@ public class SecurityProviderRegistratio
// expected size = 0 because PrincipalConfigurationImpl comes with the
default ctx
assertContext(ctx, 0, t, false);
- PrincipalConfiguration pc1 = new TestPrincipalConfiguration();
+ PrincipalConfiguration pc1 =
mockConfiguration(PrincipalConfiguration.class);
registration.bindPrincipalConfiguration(pc1, PROPS);
cpc = (CompositePrincipalConfiguration) f.get(registration);
ctx = cpc.getContext();
// expected size 1 because the PrincipalConfigurationImpl comes with
the default ctx
assertContext(ctx, 1, t, true);
- PrincipalConfiguration pc2 = new TestPrincipalConfiguration();
+ PrincipalConfiguration pc2 =
mockConfiguration(PrincipalConfiguration.class);
registration.bindPrincipalConfiguration(pc2, PROPS);
cpc = (CompositePrincipalConfiguration) f.get(registration);
ctx = cpc.getContext();
@@ -193,51 +536,35 @@ public class SecurityProviderRegistratio
assertContext(ctx, 0, t, false);
}
- private class TestAuthorizationConfiguration extends ConfigurationBase
implements AuthorizationConfiguration {
+ @Test
+ public void testBindRestrictionProviderWithoutAuthorizationConfig() {
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("serviceId"));
- @Nonnull
- @Override
- public AccessControlManager getAccessControlManager(@Nonnull Root
root, @Nonnull NamePathMapper namePathMapper) {
- return null;
- }
+ RestrictionProvider mockRp = Mockito.mock(RestrictionProvider.class);
+ registration.bindRestrictionProvider(mockRp,
ImmutableMap.of(Constants.SERVICE_PID, "serviceId"));
- @Nonnull
- @Override
- public RestrictionProvider getRestrictionProvider() {
- return null;
- }
+ SecurityProvider service = context.getService(SecurityProvider.class);
+ assertNotNull(service);
- @Nonnull
- @Override
- public PermissionProvider getPermissionProvider(@Nonnull Root root,
@Nonnull String workspaceName, @Nonnull Set<Principal> principals) {
- return null;
- }
+ AuthorizationConfiguration ac =
service.getConfiguration(AuthorizationConfiguration.class);
+ assertTrue(ac instanceof CompositeAuthorizationConfiguration);
- @Nonnull
- @Override
- public Context getContext() {
- return new ContextImpl();
- }
+ // empty composite configuration => empty rp
+ RestrictionProvider rp = ac.getRestrictionProvider();
+ assertSame(RestrictionProvider.EMPTY, rp);
}
- private class TestPrincipalConfiguration extends ConfigurationBase
implements PrincipalConfiguration {
- @Nonnull
- @Override
- public PrincipalManager getPrincipalManager(Root root, NamePathMapper
namePathMapper) {
- return null;
- }
-
- @Nonnull
- @Override
- public PrincipalProvider getPrincipalProvider(Root root,
NamePathMapper namePathMapper) {
- return null;
- }
+ @Test
+ public void testBindRestrictionProviderWithAuthorizationConfig() {
+ registration.activate(context.bundleContext(),
requiredServiceIdMap("rpId", "authorizationId"));
- @Nonnull
- @Override
- public Context getContext() {
- return new ContextImpl();
- }
+ RestrictionProvider mockRp = Mockito.mock(RestrictionProvider.class);
+ registration.bindRestrictionProvider(mockRp,
ImmutableMap.of(Constants.SERVICE_PID, "rpId"));
+ registration.bindAuthorizationConfiguration(new
AuthorizationConfigurationImpl(), ImmutableMap.of(Constants.SERVICE_PID,
"authorizationId"));
+
+ SecurityProvider service = context.getService(SecurityProvider.class);
+ RestrictionProvider rp =
service.getConfiguration(AuthorizationConfiguration.class).getRestrictionProvider();
+ assertTrue(rp instanceof WhiteboardRestrictionProvider);
}
private static class ContextImpl implements Context {
