SEC-1015: Removed acl package from core and also related taglib declaration and implementation class (AclTag).
This commit is contained in:
Luke Taylor
@@ -1,61 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security;
|
||||
|
||||
import org.springframework.security.acl.AclEntry;
|
||||
import org.springframework.security.acl.AclManager;
|
||||
|
||||
|
||||
/**
|
||||
* Returns the indicated collection of <code>AclEntry</code>s when the given <code>Authentication</code> principal
|
||||
* is presented for the indicated domain <code>Object</code> instance.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class MockAclManager implements AclManager {
|
||||
//~ Instance fields ================================================================================================
|
||||
|
||||
private Object object;
|
||||
private Object principal;
|
||||
private AclEntry[] acls;
|
||||
|
||||
//~ Constructors ===================================================================================================
|
||||
|
||||
public MockAclManager(Object domainObject, Object principal, AclEntry[] acls) {
|
||||
this.object = domainObject;
|
||||
this.principal = principal;
|
||||
this.acls = acls;
|
||||
}
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
public AclEntry[] getAcls(Object domainInstance, Authentication authentication) {
|
||||
if (domainInstance.equals(object) && authentication.getPrincipal().equals(principal)) {
|
||||
return acls;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public AclEntry[] getAcls(Object domainInstance) {
|
||||
if (domainInstance.equals(object)) {
|
||||
return acls;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,202 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.acl;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
import org.springframework.security.Authentication;
|
||||
import org.springframework.security.GrantedAuthority;
|
||||
import org.springframework.security.GrantedAuthorityImpl;
|
||||
|
||||
import org.springframework.security.acl.basic.NamedEntityObjectIdentity;
|
||||
import org.springframework.security.acl.basic.SimpleAclEntry;
|
||||
|
||||
import org.springframework.security.providers.UsernamePasswordAuthenticationToken;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Vector;
|
||||
|
||||
|
||||
/**
|
||||
* Tests {@link AclProviderManager}.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class AclProviderManagerTests extends TestCase {
|
||||
//~ Constructors ===================================================================================================
|
||||
|
||||
public AclProviderManagerTests() {
|
||||
super();
|
||||
}
|
||||
|
||||
public AclProviderManagerTests(String arg0) {
|
||||
super(arg0);
|
||||
}
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
private AclProviderManager makeProviderManager() {
|
||||
MockProvider provider1 = new MockProvider();
|
||||
List providers = new Vector();
|
||||
providers.add(provider1);
|
||||
|
||||
AclProviderManager mgr = new AclProviderManager();
|
||||
mgr.setProviders(providers);
|
||||
|
||||
return mgr;
|
||||
}
|
||||
|
||||
public final void setUp() throws Exception {
|
||||
super.setUp();
|
||||
}
|
||||
|
||||
public void testAclLookupFails() {
|
||||
AclProviderManager mgr = makeProviderManager();
|
||||
assertNull(mgr.getAcls(new Integer(5)));
|
||||
}
|
||||
|
||||
public void testAclLookupForGivenAuthenticationSuccess() {
|
||||
AclProviderManager mgr = makeProviderManager();
|
||||
assertNotNull(mgr.getAcls("STRING", new UsernamePasswordAuthenticationToken("rod", "not used")));
|
||||
}
|
||||
|
||||
public void testAclLookupSuccess() {
|
||||
AclProviderManager mgr = makeProviderManager();
|
||||
assertNotNull(mgr.getAcls("STRING"));
|
||||
}
|
||||
|
||||
public void testRejectsNulls() {
|
||||
AclProviderManager mgr = new AclProviderManager();
|
||||
|
||||
try {
|
||||
mgr.getAcls(null);
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
|
||||
try {
|
||||
mgr.getAcls(null, new UsernamePasswordAuthenticationToken("rod", "not used"));
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
|
||||
try {
|
||||
mgr.getAcls("SOME_DOMAIN_INSTANCE", null);
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testReturnsNullIfNoSupportingProvider() {
|
||||
AclProviderManager mgr = makeProviderManager();
|
||||
assertNull(mgr.getAcls(new Integer(4), new UsernamePasswordAuthenticationToken("rod", "not used")));
|
||||
assertNull(mgr.getAcls(new Integer(4)));
|
||||
}
|
||||
|
||||
public void testStartupFailsIfProviderListNotContainingProviders()
|
||||
throws Exception {
|
||||
List providers = new Vector();
|
||||
providers.add("THIS_IS_NOT_A_PROVIDER");
|
||||
|
||||
AclProviderManager mgr = new AclProviderManager();
|
||||
|
||||
try {
|
||||
mgr.setProviders(providers);
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testStartupFailsIfProviderListNotSet()
|
||||
throws Exception {
|
||||
AclProviderManager mgr = new AclProviderManager();
|
||||
|
||||
try {
|
||||
mgr.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testStartupFailsIfProviderListNull() throws Exception {
|
||||
AclProviderManager mgr = new AclProviderManager();
|
||||
|
||||
try {
|
||||
mgr.setProviders(null);
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testSuccessfulStartup() throws Exception {
|
||||
AclProviderManager mgr = makeProviderManager();
|
||||
mgr.afterPropertiesSet();
|
||||
assertTrue(true);
|
||||
assertEquals(1, mgr.getProviders().size());
|
||||
}
|
||||
|
||||
//~ Inner Classes ==================================================================================================
|
||||
|
||||
private class MockProvider implements AclProvider {
|
||||
private UsernamePasswordAuthenticationToken rod = new UsernamePasswordAuthenticationToken("rod",
|
||||
"not used",
|
||||
new GrantedAuthority[] {new GrantedAuthorityImpl("ROLE_FOO"), new GrantedAuthorityImpl("ROLE_BAR")});
|
||||
private SimpleAclEntry entry100rod = new SimpleAclEntry(rod.getPrincipal(),
|
||||
new NamedEntityObjectIdentity("OBJECT", "100"), null, 2);
|
||||
private UsernamePasswordAuthenticationToken scott = new UsernamePasswordAuthenticationToken("scott",
|
||||
"not used",
|
||||
new GrantedAuthority[] {
|
||||
new GrantedAuthorityImpl("ROLE_FOO"),
|
||||
new GrantedAuthorityImpl("ROLE_MANAGER")
|
||||
});
|
||||
private SimpleAclEntry entry100Scott = new SimpleAclEntry(scott.getPrincipal(),
|
||||
new NamedEntityObjectIdentity("OBJECT", "100"), null, 4);
|
||||
|
||||
public AclEntry[] getAcls(Object domainInstance, Authentication authentication) {
|
||||
if (authentication.getPrincipal().equals(scott.getPrincipal())) {
|
||||
return new AclEntry[] {entry100Scott};
|
||||
}
|
||||
|
||||
if (authentication.getPrincipal().equals(rod.getPrincipal())) {
|
||||
return new AclEntry[] {entry100rod};
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public AclEntry[] getAcls(Object domainInstance) {
|
||||
return new AclEntry[] {entry100rod, entry100Scott};
|
||||
}
|
||||
|
||||
/**
|
||||
* Only supports <code>Object</code>s of type <code>String</code>
|
||||
*
|
||||
* @param domainInstance DOCUMENT ME!
|
||||
*
|
||||
* @return DOCUMENT ME!
|
||||
*/
|
||||
public boolean supports(Object domainInstance) {
|
||||
return (domainInstance instanceof String);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,391 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.acl.basic;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
import org.springframework.security.Authentication;
|
||||
import org.springframework.security.PopulatedDatabase;
|
||||
|
||||
import org.springframework.security.acl.AclEntry;
|
||||
import org.springframework.security.acl.basic.cache.BasicAclEntryHolder;
|
||||
import org.springframework.security.acl.basic.cache.NullAclEntryCache;
|
||||
import org.springframework.security.acl.basic.jdbc.JdbcDaoImpl;
|
||||
|
||||
import org.springframework.security.providers.UsernamePasswordAuthenticationToken;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
|
||||
/**
|
||||
* Tests {@link BasicAclProvider}.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class BasicAclProviderTests extends TestCase {
|
||||
//~ Static fields/initializers =====================================================================================
|
||||
|
||||
public static final String OBJECT_IDENTITY = "org.springframework.security.acl.DomainObject";
|
||||
|
||||
//~ Constructors ===================================================================================================
|
||||
|
||||
public BasicAclProviderTests() {
|
||||
super();
|
||||
}
|
||||
|
||||
public BasicAclProviderTests(String arg0) {
|
||||
super(arg0);
|
||||
}
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
public static void main(String[] args) {
|
||||
junit.textui.TestRunner.run(BasicAclProviderTests.class);
|
||||
}
|
||||
|
||||
private JdbcDaoImpl makePopulatedJdbcDao() throws Exception {
|
||||
JdbcDaoImpl dao = new JdbcDaoImpl();
|
||||
dao.setDataSource(PopulatedDatabase.getDataSource());
|
||||
dao.afterPropertiesSet();
|
||||
|
||||
return dao;
|
||||
}
|
||||
|
||||
public final void setUp() throws Exception {
|
||||
super.setUp();
|
||||
}
|
||||
|
||||
public void testCachingUsedProperly() throws Exception {
|
||||
BasicAclProvider provider = new BasicAclProvider();
|
||||
provider.setBasicAclDao(makePopulatedJdbcDao());
|
||||
|
||||
MockCache cache = new MockCache();
|
||||
provider.setBasicAclEntryCache(cache);
|
||||
|
||||
assertEquals(0, cache.getGets());
|
||||
assertEquals(0, cache.getGetsHits());
|
||||
assertEquals(0, cache.getPuts());
|
||||
assertEquals(0, cache.getBackingMap().size());
|
||||
|
||||
Object object = new MockDomain(1); // has no parents
|
||||
provider.getAcls(object);
|
||||
|
||||
assertEquals(1, cache.getGets());
|
||||
assertEquals(0, cache.getGetsHits());
|
||||
assertEquals(1, cache.getPuts());
|
||||
assertEquals(1, cache.getBackingMap().size());
|
||||
|
||||
provider.getAcls(object);
|
||||
|
||||
assertEquals(2, cache.getGets());
|
||||
assertEquals(1, cache.getGetsHits());
|
||||
assertEquals(1, cache.getPuts());
|
||||
assertEquals(1, cache.getBackingMap().size());
|
||||
|
||||
object = new MockDomain(1000); // does not exist
|
||||
|
||||
provider.getAcls(object);
|
||||
|
||||
assertEquals(3, cache.getGets());
|
||||
assertEquals(1, cache.getGetsHits());
|
||||
assertEquals(2, cache.getPuts());
|
||||
assertEquals(2, cache.getBackingMap().size());
|
||||
|
||||
provider.getAcls(object);
|
||||
|
||||
assertEquals(4, cache.getGets());
|
||||
assertEquals(2, cache.getGetsHits());
|
||||
assertEquals(2, cache.getPuts());
|
||||
assertEquals(2, cache.getBackingMap().size());
|
||||
|
||||
provider.getAcls(object);
|
||||
|
||||
assertEquals(5, cache.getGets());
|
||||
assertEquals(3, cache.getGetsHits());
|
||||
assertEquals(2, cache.getPuts());
|
||||
assertEquals(2, cache.getBackingMap().size());
|
||||
}
|
||||
|
||||
public void testExceptionThrownIfUnsupportedObjectIsSubmitted()
|
||||
throws Exception {
|
||||
BasicAclProvider provider = new BasicAclProvider();
|
||||
provider.setBasicAclDao(makePopulatedJdbcDao());
|
||||
|
||||
// this one should NOT be supported, as it has no getId() method
|
||||
assertFalse(provider.supports(new Integer(34)));
|
||||
|
||||
// try anyway
|
||||
try {
|
||||
provider.getAcls(new Integer(34));
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testGetAclsForInstanceNotFound() throws Exception {
|
||||
BasicAclProvider provider = new BasicAclProvider();
|
||||
provider.setBasicAclDao(makePopulatedJdbcDao());
|
||||
|
||||
Object object = new MockDomain(546464646);
|
||||
AclEntry[] acls = provider.getAcls(object);
|
||||
assertNull(acls);
|
||||
}
|
||||
|
||||
public void testGetAclsForInstanceWithParentLevels()
|
||||
throws Exception {
|
||||
BasicAclProvider provider = new BasicAclProvider();
|
||||
provider.setBasicAclDao(makePopulatedJdbcDao());
|
||||
|
||||
Object object = new MockDomain(6);
|
||||
AclEntry[] acls = provider.getAcls(object);
|
||||
assertEquals(2, acls.length);
|
||||
|
||||
assertEquals("scott", ((BasicAclEntry) acls[0]).getRecipient());
|
||||
assertEquals(1, ((BasicAclEntry) acls[0]).getMask());
|
||||
assertEquals("ROLE_SUPERVISOR", ((BasicAclEntry) acls[1]).getRecipient());
|
||||
}
|
||||
|
||||
public void testGetAclsForInstanceWithParentLevelsButNoDirectAclsAgainstInstance()
|
||||
throws Exception {
|
||||
BasicAclProvider provider = new BasicAclProvider();
|
||||
provider.setBasicAclDao(makePopulatedJdbcDao());
|
||||
|
||||
Object object = new MockDomain(5);
|
||||
AclEntry[] acls = provider.getAcls(object);
|
||||
|
||||
assertEquals(3, acls.length);
|
||||
|
||||
assertEquals("scott", ((BasicAclEntry) acls[0]).getRecipient());
|
||||
assertEquals(14, ((BasicAclEntry) acls[0]).getMask());
|
||||
assertEquals("ROLE_SUPERVISOR", ((BasicAclEntry) acls[1]).getRecipient());
|
||||
assertEquals(1, ((BasicAclEntry) acls[1]).getMask());
|
||||
assertEquals(JdbcDaoImpl.RECIPIENT_USED_FOR_INHERITENCE_MARKER, ((BasicAclEntry) acls[2]).getRecipient());
|
||||
}
|
||||
|
||||
public void testGetAclsWithAuthentication() throws Exception {
|
||||
BasicAclProvider provider = new BasicAclProvider();
|
||||
provider.setBasicAclDao(makePopulatedJdbcDao());
|
||||
|
||||
Authentication scott = new UsernamePasswordAuthenticationToken("scott", "unused");
|
||||
|
||||
Object object = new MockDomain(6);
|
||||
AclEntry[] acls = provider.getAcls(object, scott);
|
||||
|
||||
assertEquals(1, acls.length);
|
||||
assertEquals("scott", ((BasicAclEntry) acls[0]).getRecipient());
|
||||
}
|
||||
|
||||
public void testGettersSetters() {
|
||||
BasicAclProvider provider = new BasicAclProvider();
|
||||
assertEquals(NullAclEntryCache.class, provider.getBasicAclEntryCache().getClass());
|
||||
assertEquals(NamedEntityObjectIdentity.class, provider.getDefaultAclObjectIdentityClass());
|
||||
assertEquals(GrantedAuthorityEffectiveAclsResolver.class, provider.getEffectiveAclsResolver().getClass());
|
||||
|
||||
provider.setBasicAclEntryCache(null);
|
||||
assertNull(provider.getBasicAclEntryCache());
|
||||
|
||||
provider.setDefaultAclObjectIdentityClass(null);
|
||||
assertNull(provider.getDefaultAclObjectIdentityClass());
|
||||
|
||||
provider.setEffectiveAclsResolver(null);
|
||||
assertNull(provider.getEffectiveAclsResolver());
|
||||
|
||||
provider.setBasicAclDao(new MockDao());
|
||||
assertNotNull(provider.getBasicAclDao());
|
||||
|
||||
assertNull(provider.getRestrictSupportToClass());
|
||||
provider.setRestrictSupportToClass(SomeDomain.class);
|
||||
assertEquals(SomeDomain.class, provider.getRestrictSupportToClass());
|
||||
}
|
||||
|
||||
public void testStartupFailsIfNullAclDao() throws Exception {
|
||||
BasicAclProvider provider = new BasicAclProvider();
|
||||
|
||||
try {
|
||||
provider.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testStartupFailsIfNullEffectiveAclsResolver()
|
||||
throws Exception {
|
||||
BasicAclProvider provider = new BasicAclProvider();
|
||||
provider.setBasicAclDao(makePopulatedJdbcDao());
|
||||
|
||||
provider.setEffectiveAclsResolver(null);
|
||||
|
||||
try {
|
||||
provider.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testStartupFailsIfNullEntryCache() throws Exception {
|
||||
BasicAclProvider provider = new BasicAclProvider();
|
||||
provider.setBasicAclDao(makePopulatedJdbcDao());
|
||||
|
||||
provider.setBasicAclEntryCache(null);
|
||||
|
||||
try {
|
||||
provider.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testStartupFailsIfProblemWithAclObjectIdentityClass()
|
||||
throws Exception {
|
||||
BasicAclProvider provider = new BasicAclProvider();
|
||||
provider.setBasicAclDao(makePopulatedJdbcDao());
|
||||
|
||||
// check nulls rejected
|
||||
provider.setDefaultAclObjectIdentityClass(null);
|
||||
|
||||
try {
|
||||
provider.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
|
||||
// check non-AclObjectIdentity classes are also rejected
|
||||
provider.setDefaultAclObjectIdentityClass(String.class);
|
||||
|
||||
try {
|
||||
provider.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
|
||||
// check AclObjectIdentity class without constructor accepting a
|
||||
// domain object is also rejected
|
||||
provider.setDefaultAclObjectIdentityClass(MockAclObjectIdentity.class);
|
||||
|
||||
try {
|
||||
provider.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertEquals("defaultAclObjectIdentityClass must provide a constructor that accepts the domain object instance!",
|
||||
expected.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
public void testSupports() throws Exception {
|
||||
BasicAclProvider provider = new BasicAclProvider();
|
||||
provider.setBasicAclDao(makePopulatedJdbcDao());
|
||||
|
||||
// this one should NOT be supported, as it has no getId() method
|
||||
assertFalse(provider.supports(new Integer(34)));
|
||||
|
||||
// this one SHOULD be supported, as it has a getId() method
|
||||
assertTrue(provider.supports(new SomeDomain()));
|
||||
|
||||
// this one SHOULD be supported, as it implements AclObjectIdentityAware
|
||||
assertTrue(provider.supports(new MockDomain(4)));
|
||||
|
||||
// now restrict the provider to only respond to SomeDomain.class requests
|
||||
provider.setRestrictSupportToClass(SomeDomain.class);
|
||||
assertEquals(SomeDomain.class, provider.getRestrictSupportToClass());
|
||||
|
||||
// this one SHOULD be supported, as it has a getId() method AND it meets the restrictSupportToClass criteria
|
||||
assertTrue(provider.supports(new SomeDomain()));
|
||||
|
||||
// this one should NOT be suported, as whilst it implement AclObjectIdentityAware (as proven earlier in the test), it does NOT meet the restrictSupportToClass criteria
|
||||
assertFalse(provider.supports(new MockDomain(4)));
|
||||
}
|
||||
|
||||
public void testSupportsReturnsNullIfObjectNull() {
|
||||
BasicAclProvider provider = new BasicAclProvider();
|
||||
assertFalse(provider.supports(new Integer(34)));
|
||||
}
|
||||
|
||||
//~ Inner Classes ==================================================================================================
|
||||
|
||||
private class MockCache implements BasicAclEntryCache {
|
||||
private Map map = new HashMap();
|
||||
private int gets = 0;
|
||||
private int getsHits = 0;
|
||||
private int puts = 0;
|
||||
|
||||
public Map getBackingMap() {
|
||||
return map;
|
||||
}
|
||||
|
||||
public BasicAclEntry[] getEntriesFromCache(AclObjectIdentity aclObjectIdentity) {
|
||||
gets++;
|
||||
|
||||
Object result = map.get(aclObjectIdentity);
|
||||
|
||||
if (result == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
getsHits++;
|
||||
|
||||
BasicAclEntryHolder holder = (BasicAclEntryHolder) result;
|
||||
|
||||
return holder.getBasicAclEntries();
|
||||
}
|
||||
|
||||
public int getGets() {
|
||||
return gets;
|
||||
}
|
||||
|
||||
public int getGetsHits() {
|
||||
return getsHits;
|
||||
}
|
||||
|
||||
public int getPuts() {
|
||||
return puts;
|
||||
}
|
||||
|
||||
public void putEntriesInCache(BasicAclEntry[] basicAclEntry) {
|
||||
puts++;
|
||||
|
||||
BasicAclEntryHolder holder = new BasicAclEntryHolder(basicAclEntry);
|
||||
map.put(basicAclEntry[0].getAclObjectIdentity(), holder);
|
||||
}
|
||||
|
||||
public void removeEntriesFromCache(AclObjectIdentity aclObjectIdentity) {}
|
||||
}
|
||||
|
||||
private class MockDao implements BasicAclDao {
|
||||
public BasicAclEntry[] getAcls(AclObjectIdentity aclObjectIdentity) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private class MockDomain implements AclObjectIdentityAware {
|
||||
private int id;
|
||||
|
||||
public MockDomain(int id) {
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
public AclObjectIdentity getAclObjectIdentity() {
|
||||
return new NamedEntityObjectIdentity(OBJECT_IDENTITY, new Integer(id).toString());
|
||||
}
|
||||
}
|
||||
}
|
||||
-132
@@ -1,132 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.acl.basic;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
import org.springframework.security.GrantedAuthority;
|
||||
import org.springframework.security.GrantedAuthorityImpl;
|
||||
|
||||
import org.springframework.security.acl.AclEntry;
|
||||
|
||||
import org.springframework.security.providers.UsernamePasswordAuthenticationToken;
|
||||
|
||||
import org.springframework.security.userdetails.User;
|
||||
|
||||
|
||||
/**
|
||||
* Tests {@link GrantedAuthorityEffectiveAclsResolver}.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class GrantedAuthorityEffectiveAclsResolverTests extends TestCase {
|
||||
//~ Instance fields ================================================================================================
|
||||
|
||||
private SimpleAclEntry entry100RoleEverybody = new SimpleAclEntry("ROLE_EVERYBODY",
|
||||
new NamedEntityObjectIdentity("OBJECT", "100"), null, 14);
|
||||
private SimpleAclEntry entry100RoleOne = new SimpleAclEntry("ROLE_ONE",
|
||||
new NamedEntityObjectIdentity("OBJECT", "100"), null, 0);
|
||||
private SimpleAclEntry entry100RoleTwo = new SimpleAclEntry("ROLE_TWO",
|
||||
new NamedEntityObjectIdentity("OBJECT", "100"), null, 2);
|
||||
private UsernamePasswordAuthenticationToken scott = new UsernamePasswordAuthenticationToken("scott", "not used",
|
||||
new GrantedAuthority[] {new GrantedAuthorityImpl("ROLE_EVERYBODY"), new GrantedAuthorityImpl("ROLE_TWO")});
|
||||
private SimpleAclEntry entry100Scott = new SimpleAclEntry(scott.getPrincipal(),
|
||||
new NamedEntityObjectIdentity("OBJECT", "100"), null, 4);
|
||||
private UsernamePasswordAuthenticationToken dianne = new UsernamePasswordAuthenticationToken("dianne", "not used");
|
||||
private UsernamePasswordAuthenticationToken rod = new UsernamePasswordAuthenticationToken("rod",
|
||||
"not used",
|
||||
new GrantedAuthority[] {new GrantedAuthorityImpl("ROLE_EVERYBODY"), new GrantedAuthorityImpl("ROLE_ONE")});
|
||||
private SimpleAclEntry entry100rod = new SimpleAclEntry(rod.getPrincipal(),
|
||||
new NamedEntityObjectIdentity("OBJECT", "100"), null, 2);
|
||||
private UsernamePasswordAuthenticationToken scottWithUserDetails = new UsernamePasswordAuthenticationToken(new User(
|
||||
"scott", "NOT_USED", true, true, true, true,
|
||||
new GrantedAuthority[] {new GrantedAuthorityImpl("ROLE_EVERYBODY")}), "not used",
|
||||
new GrantedAuthority[] {new GrantedAuthorityImpl("ROLE_EVERYBODY"), new GrantedAuthorityImpl("ROLE_TWO")});
|
||||
|
||||
// convenience group
|
||||
private SimpleAclEntry[] acls = {
|
||||
entry100rod, entry100Scott, entry100RoleEverybody, entry100RoleOne, entry100RoleTwo
|
||||
};
|
||||
|
||||
//~ Constructors ===================================================================================================
|
||||
|
||||
public GrantedAuthorityEffectiveAclsResolverTests() {
|
||||
super();
|
||||
}
|
||||
|
||||
public GrantedAuthorityEffectiveAclsResolverTests(String arg0) {
|
||||
super(arg0);
|
||||
}
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
public static void main(String[] args) {
|
||||
junit.textui.TestRunner.run(GrantedAuthorityEffectiveAclsResolverTests.class);
|
||||
}
|
||||
|
||||
public final void setUp() throws Exception {
|
||||
super.setUp();
|
||||
}
|
||||
|
||||
public void testResolveAclsForDianneWhoHasANullForAuthorities() {
|
||||
GrantedAuthorityEffectiveAclsResolver resolver = new GrantedAuthorityEffectiveAclsResolver();
|
||||
assertNull(resolver.resolveEffectiveAcls(acls, dianne));
|
||||
}
|
||||
|
||||
public void testResolveAclsForrod() {
|
||||
GrantedAuthorityEffectiveAclsResolver resolver = new GrantedAuthorityEffectiveAclsResolver();
|
||||
assertEquals(3, resolver.resolveEffectiveAcls(acls, rod).length);
|
||||
assertEquals(entry100rod, resolver.resolveEffectiveAcls(acls, rod)[0]);
|
||||
assertEquals(entry100RoleEverybody, resolver.resolveEffectiveAcls(acls, rod)[1]);
|
||||
assertEquals(entry100RoleOne, resolver.resolveEffectiveAcls(acls, rod)[2]);
|
||||
}
|
||||
|
||||
public void testResolveAclsForScottWithStringObjectAsPrincipal() {
|
||||
GrantedAuthorityEffectiveAclsResolver resolver = new GrantedAuthorityEffectiveAclsResolver();
|
||||
assertEquals(3, resolver.resolveEffectiveAcls(acls, scott).length);
|
||||
assertEquals(entry100Scott, resolver.resolveEffectiveAcls(acls, scott)[0]);
|
||||
assertEquals(entry100RoleEverybody, resolver.resolveEffectiveAcls(acls, scott)[1]);
|
||||
assertEquals(entry100RoleTwo, resolver.resolveEffectiveAcls(acls, scott)[2]);
|
||||
}
|
||||
|
||||
public void testResolveAclsForScottWithUserDetailsObjectAsPrincipal() {
|
||||
GrantedAuthorityEffectiveAclsResolver resolver = new GrantedAuthorityEffectiveAclsResolver();
|
||||
assertEquals(3, resolver.resolveEffectiveAcls(acls, scottWithUserDetails).length);
|
||||
assertEquals(entry100Scott, resolver.resolveEffectiveAcls(acls, scottWithUserDetails)[0]);
|
||||
assertEquals(entry100RoleEverybody, resolver.resolveEffectiveAcls(acls, scottWithUserDetails)[1]);
|
||||
assertEquals(entry100RoleTwo, resolver.resolveEffectiveAcls(acls, scottWithUserDetails)[2]);
|
||||
}
|
||||
|
||||
public void testResolveAclsReturnsNullIfNoAclsInFirstPlace() {
|
||||
GrantedAuthorityEffectiveAclsResolver resolver = new GrantedAuthorityEffectiveAclsResolver();
|
||||
assertNull(resolver.resolveEffectiveAcls(null, scott));
|
||||
}
|
||||
|
||||
public void testSkipsNonBasicAclEntryObjects() {
|
||||
GrantedAuthorityEffectiveAclsResolver resolver = new GrantedAuthorityEffectiveAclsResolver();
|
||||
AclEntry[] basicAcls = {
|
||||
entry100rod, entry100Scott, entry100RoleEverybody, entry100RoleOne, new MockAcl(), entry100RoleTwo
|
||||
};
|
||||
assertEquals(3, resolver.resolveEffectiveAcls(basicAcls, rod).length);
|
||||
}
|
||||
|
||||
//~ Inner Classes ==================================================================================================
|
||||
|
||||
private class MockAcl implements AclEntry {
|
||||
// does nothing
|
||||
}
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.acl.basic;
|
||||
|
||||
/**
|
||||
* Implements <code>AclObjectIdentity</code> but is incompatible with <code>BasicAclProvider</code> because it
|
||||
* cannot be constructed by passing in a domain object instance.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class MockAclObjectIdentity implements AclObjectIdentity {
|
||||
// has no "public MockAclObjectIdentity(Object object)" constructor!
|
||||
}
|
||||
-134
@@ -1,134 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.acl.basic;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
|
||||
/**
|
||||
* Tests {@link NamedEntityObjectIdentity}.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class NamedEntityObjectIdentityTests extends TestCase {
|
||||
//~ Constructors ===================================================================================================
|
||||
|
||||
public NamedEntityObjectIdentityTests() {
|
||||
super();
|
||||
}
|
||||
|
||||
public NamedEntityObjectIdentityTests(String arg0) {
|
||||
super(arg0);
|
||||
}
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
public static void main(String[] args) {
|
||||
junit.textui.TestRunner.run(NamedEntityObjectIdentityTests.class);
|
||||
}
|
||||
|
||||
public final void setUp() throws Exception {
|
||||
super.setUp();
|
||||
}
|
||||
|
||||
public void testConstructionViaReflection() throws Exception {
|
||||
SomeDomain domainObject = new SomeDomain();
|
||||
domainObject.setId(34);
|
||||
|
||||
NamedEntityObjectIdentity name = new NamedEntityObjectIdentity(domainObject);
|
||||
assertEquals("34", name.getId());
|
||||
assertEquals(domainObject.getClass().getName(), name.getClassname());
|
||||
name.toString();
|
||||
}
|
||||
|
||||
public void testConstructionViaReflectionFailsIfNoGetIdMethod()
|
||||
throws Exception {
|
||||
try {
|
||||
new NamedEntityObjectIdentity(new Integer(45));
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testConstructionViaReflectionFailsIfNullPassed()
|
||||
throws Exception {
|
||||
try {
|
||||
new NamedEntityObjectIdentity(null);
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testEquality() {
|
||||
NamedEntityObjectIdentity original = new NamedEntityObjectIdentity("foo", "12");
|
||||
assertFalse(original.equals(null));
|
||||
assertFalse(original.equals(new Integer(354)));
|
||||
assertFalse(original.equals(new NamedEntityObjectIdentity("foo", "23232")));
|
||||
assertTrue(original.equals(new NamedEntityObjectIdentity("foo", "12")));
|
||||
assertTrue(original.equals(original));
|
||||
}
|
||||
|
||||
public void testNoArgConstructorDoesntExist() {
|
||||
Class clazz = NamedEntityObjectIdentity.class;
|
||||
|
||||
try {
|
||||
clazz.getDeclaredConstructor((Class[]) null);
|
||||
fail("Should have thrown NoSuchMethodException");
|
||||
} catch (NoSuchMethodException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testNormalConstructionRejectedIfInvalidArguments()
|
||||
throws Exception {
|
||||
try {
|
||||
new NamedEntityObjectIdentity(null, "12");
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
|
||||
try {
|
||||
new NamedEntityObjectIdentity("classname", null);
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
|
||||
try {
|
||||
new NamedEntityObjectIdentity("", "12");
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
|
||||
try {
|
||||
new NamedEntityObjectIdentity("classname", "");
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testNormalOperation() {
|
||||
NamedEntityObjectIdentity name = new NamedEntityObjectIdentity("domain", "id");
|
||||
assertEquals("domain", name.getClassname());
|
||||
assertEquals("id", name.getId());
|
||||
}
|
||||
}
|
||||
@@ -1,207 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.acl.basic;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
/**
|
||||
* Tests {@link SimpleAclEntry}.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class SimpleAclEntryTests extends TestCase {
|
||||
//~ Constructors ===================================================================================================
|
||||
|
||||
public SimpleAclEntryTests() {
|
||||
super();
|
||||
}
|
||||
|
||||
public SimpleAclEntryTests(String arg0) {
|
||||
super(arg0);
|
||||
}
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
public static void main(String[] args) {
|
||||
junit.textui.TestRunner.run(SimpleAclEntryTests.class);
|
||||
}
|
||||
|
||||
public final void setUp() throws Exception {
|
||||
super.setUp();
|
||||
}
|
||||
|
||||
public void testCorrectOperation() {
|
||||
String recipient = "rod";
|
||||
AclObjectIdentity objectIdentity = new NamedEntityObjectIdentity("domain", "12");
|
||||
SimpleAclEntry acl = new SimpleAclEntry(recipient, objectIdentity, null, 0);
|
||||
|
||||
assertFalse(acl.isPermitted(SimpleAclEntry.ADMINISTRATION));
|
||||
acl.addPermission(SimpleAclEntry.ADMINISTRATION);
|
||||
assertTrue(acl.isPermitted(SimpleAclEntry.ADMINISTRATION));
|
||||
assertFalse(acl.isPermitted(SimpleAclEntry.CREATE));
|
||||
assertFalse(acl.isPermitted(SimpleAclEntry.DELETE));
|
||||
assertFalse(acl.isPermitted(SimpleAclEntry.READ));
|
||||
assertFalse(acl.isPermitted(SimpleAclEntry.WRITE));
|
||||
assertEquals("A----", acl.printPermissionsBlock());
|
||||
acl.deletePermission(SimpleAclEntry.ADMINISTRATION);
|
||||
assertFalse(acl.isPermitted(SimpleAclEntry.ADMINISTRATION));
|
||||
assertEquals("-----", acl.printPermissionsBlock());
|
||||
|
||||
acl.addPermissions(new int[] {SimpleAclEntry.READ, SimpleAclEntry.WRITE});
|
||||
acl.addPermission(SimpleAclEntry.CREATE);
|
||||
assertFalse(acl.isPermitted(SimpleAclEntry.ADMINISTRATION));
|
||||
assertTrue(acl.isPermitted(SimpleAclEntry.CREATE));
|
||||
assertFalse(acl.isPermitted(SimpleAclEntry.DELETE));
|
||||
assertTrue(acl.isPermitted(SimpleAclEntry.READ));
|
||||
assertTrue(acl.isPermitted(SimpleAclEntry.WRITE));
|
||||
assertEquals("-RWC-", acl.printPermissionsBlock());
|
||||
|
||||
acl.deletePermission(SimpleAclEntry.CREATE);
|
||||
acl.deletePermissions(new int[] {SimpleAclEntry.READ, SimpleAclEntry.WRITE});
|
||||
assertEquals("-----", acl.printPermissionsBlock());
|
||||
|
||||
acl.togglePermission(SimpleAclEntry.CREATE);
|
||||
assertTrue(acl.isPermitted(SimpleAclEntry.CREATE));
|
||||
assertFalse(acl.isPermitted(SimpleAclEntry.ADMINISTRATION));
|
||||
acl.togglePermission(SimpleAclEntry.CREATE);
|
||||
assertFalse(acl.isPermitted(SimpleAclEntry.CREATE));
|
||||
|
||||
acl.togglePermission(SimpleAclEntry.DELETE);
|
||||
assertTrue(acl.isPermitted(SimpleAclEntry.DELETE));
|
||||
assertEquals("----D", acl.printPermissionsBlock());
|
||||
}
|
||||
|
||||
public void testDetectsNullOnMainConstructor() {
|
||||
String recipient = "rod";
|
||||
AclObjectIdentity objectIdentity = new NamedEntityObjectIdentity("domain", "12");
|
||||
|
||||
try {
|
||||
new SimpleAclEntry(recipient, null, null, 2);
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
|
||||
try {
|
||||
new SimpleAclEntry(null, objectIdentity, null, 2);
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testGettersSetters() {
|
||||
SimpleAclEntry acl = new SimpleAclEntry();
|
||||
|
||||
AclObjectIdentity objectIdentity = new NamedEntityObjectIdentity("domain", "693");
|
||||
acl.setAclObjectIdentity(objectIdentity);
|
||||
assertEquals(objectIdentity, acl.getAclObjectIdentity());
|
||||
|
||||
AclObjectIdentity parentObjectIdentity = new NamedEntityObjectIdentity("domain", "13");
|
||||
acl.setAclObjectParentIdentity(parentObjectIdentity);
|
||||
assertEquals(parentObjectIdentity, acl.getAclObjectParentIdentity());
|
||||
|
||||
acl.setMask(2);
|
||||
assertEquals(2, acl.getMask());
|
||||
|
||||
acl.setRecipient("scott");
|
||||
assertEquals("scott", acl.getRecipient());
|
||||
}
|
||||
|
||||
public void testRejectsInvalidMasksInAddMethod() {
|
||||
String recipient = "rod";
|
||||
AclObjectIdentity objectIdentity = new NamedEntityObjectIdentity("domain", "12");
|
||||
SimpleAclEntry acl = new SimpleAclEntry(recipient, objectIdentity, null, 4);
|
||||
|
||||
try {
|
||||
acl.addPermission(Integer.MAX_VALUE);
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testRejectsInvalidMasksInDeleteMethod() {
|
||||
String recipient = "rod";
|
||||
AclObjectIdentity objectIdentity = new NamedEntityObjectIdentity("domain", "12");
|
||||
SimpleAclEntry acl = new SimpleAclEntry(recipient, objectIdentity, null, 0);
|
||||
acl.addPermissions(new int[] {SimpleAclEntry.READ, SimpleAclEntry.WRITE, SimpleAclEntry.CREATE});
|
||||
|
||||
try {
|
||||
acl.deletePermission(SimpleAclEntry.READ); // can't write if we can't read
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testRejectsInvalidMasksInTogglePermissionMethod() {
|
||||
String recipient = "rod";
|
||||
AclObjectIdentity objectIdentity = new NamedEntityObjectIdentity("domain", "12");
|
||||
SimpleAclEntry acl = new SimpleAclEntry(recipient, objectIdentity, null, 0);
|
||||
acl.addPermissions(new int[] {SimpleAclEntry.READ, SimpleAclEntry.WRITE, SimpleAclEntry.CREATE});
|
||||
|
||||
try {
|
||||
acl.togglePermission(SimpleAclEntry.READ); // can't write if we can't read
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testToString() {
|
||||
String recipient = "rod";
|
||||
AclObjectIdentity objectIdentity = new NamedEntityObjectIdentity("domain", "12");
|
||||
SimpleAclEntry acl = new SimpleAclEntry(recipient, objectIdentity, null, 0);
|
||||
acl.addPermissions(new int[] {SimpleAclEntry.READ, SimpleAclEntry.WRITE, SimpleAclEntry.CREATE});
|
||||
assertTrue(acl.toString().endsWith("rod=-RWC- ............................111. (14)]"));
|
||||
}
|
||||
|
||||
public void testParsePermission() {
|
||||
assertPermission("NOTHING", SimpleAclEntry.NOTHING);
|
||||
assertPermission("ADMINISTRATION", SimpleAclEntry.ADMINISTRATION);
|
||||
assertPermission("READ", SimpleAclEntry.READ);
|
||||
assertPermission("WRITE", SimpleAclEntry.WRITE);
|
||||
assertPermission("CREATE", SimpleAclEntry.CREATE);
|
||||
assertPermission("DELETE", SimpleAclEntry.DELETE);
|
||||
assertPermission("READ_WRITE_DELETE", SimpleAclEntry.READ_WRITE_DELETE);
|
||||
}
|
||||
|
||||
public void testParsePermissionWrongValues() {
|
||||
try {
|
||||
SimpleAclEntry.parsePermission("X");
|
||||
fail(IllegalArgumentException.class.getName() + " must have been thrown.");
|
||||
} catch (IllegalArgumentException e) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
|
||||
private void assertPermission(String permission, int value) {
|
||||
assertEquals(value, SimpleAclEntry.parsePermission(permission));
|
||||
}
|
||||
|
||||
/**
|
||||
* Check that the value returned by {@link SimpleAclEntry#getValidPermissions()} is not modifiable.
|
||||
*/
|
||||
public void testGetPermissions() {
|
||||
SimpleAclEntry acl = new SimpleAclEntry("", new NamedEntityObjectIdentity("x", "x"), null, 0);
|
||||
int[] permissions = acl.getValidPermissions();
|
||||
int i = permissions[0];
|
||||
permissions[0] -= 100;
|
||||
assertEquals("Value returned by getValidPermissions can be modified", i, acl.getValidPermissions()[0]);
|
||||
}
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.acl.basic;
|
||||
|
||||
/**
|
||||
* Simple object to use when testing <code>NamedEntityObjectIdentity</code>.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class SomeDomain {
|
||||
//~ Instance fields ================================================================================================
|
||||
|
||||
private int id;
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
public int getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
public void setId(int id) {
|
||||
this.id = id;
|
||||
}
|
||||
}
|
||||
Vendored
-66
@@ -1,66 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.acl.basic.cache;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
import org.springframework.security.acl.basic.BasicAclEntry;
|
||||
import org.springframework.security.acl.basic.SimpleAclEntry;
|
||||
|
||||
|
||||
/**
|
||||
* Tests {@link BasicAclEntryHolder}.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class BasicAclEntryHolderTests extends TestCase {
|
||||
//~ Constructors ===================================================================================================
|
||||
|
||||
public BasicAclEntryHolderTests() {
|
||||
super();
|
||||
}
|
||||
|
||||
public BasicAclEntryHolderTests(String arg0) {
|
||||
super(arg0);
|
||||
}
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
public static void main(String[] args) {
|
||||
junit.textui.TestRunner.run(BasicAclEntryHolderTests.class);
|
||||
}
|
||||
|
||||
public final void setUp() throws Exception {
|
||||
super.setUp();
|
||||
}
|
||||
|
||||
public void testRejectsNull() throws Exception {
|
||||
try {
|
||||
new BasicAclEntryHolder(null);
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
|
||||
try {
|
||||
new BasicAclEntryHolder(new BasicAclEntry[] {new SimpleAclEntry(), null, new SimpleAclEntry()});
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
Vendored
-106
@@ -1,106 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.acl.basic.cache;
|
||||
|
||||
import net.sf.ehcache.Ehcache;
|
||||
import net.sf.ehcache.CacheManager;
|
||||
import net.sf.ehcache.Cache;
|
||||
|
||||
import org.springframework.security.acl.basic.AclObjectIdentity;
|
||||
import org.springframework.security.acl.basic.BasicAclEntry;
|
||||
import org.springframework.security.acl.basic.NamedEntityObjectIdentity;
|
||||
import org.springframework.security.acl.basic.SimpleAclEntry;
|
||||
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.AfterClass;
|
||||
import org.junit.Test;
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
|
||||
/**
|
||||
* Tests {@link EhCacheBasedAclEntryCache}.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class EhCacheBasedAclEntryCacheTests {
|
||||
//~ Static fields/initializers =====================================================================================
|
||||
|
||||
private static final AclObjectIdentity OBJECT_100 = new NamedEntityObjectIdentity("OBJECT", "100");
|
||||
private static final AclObjectIdentity OBJECT_200 = new NamedEntityObjectIdentity("OBJECT", "200");
|
||||
private static final BasicAclEntry OBJECT_100_ROD = new SimpleAclEntry("rod", OBJECT_100, null, 2);
|
||||
private static final BasicAclEntry OBJECT_100_SCOTT = new SimpleAclEntry("scott", OBJECT_100, null, 4);
|
||||
private static final BasicAclEntry OBJECT_200_PETER = new SimpleAclEntry("peter", OBJECT_200, null, 4);
|
||||
|
||||
private static CacheManager cacheManager;
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
@BeforeClass
|
||||
public static void initCacheManaer() {
|
||||
cacheManager = new CacheManager();
|
||||
cacheManager.addCache(new Cache("ehcachebasedacltests", 500, false, false, 30, 30));
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void shutdownCacheManager() {
|
||||
cacheManager.removalAll();
|
||||
cacheManager.shutdown();
|
||||
}
|
||||
|
||||
private Ehcache getCache() {
|
||||
Ehcache cache = cacheManager.getCache("ehcachebasedacltests");
|
||||
cache.removeAll();
|
||||
|
||||
return cache;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void cacheOperationSucceeds() throws Exception {
|
||||
EhCacheBasedAclEntryCache cache = new EhCacheBasedAclEntryCache();
|
||||
cache.setCache(getCache());
|
||||
cache.afterPropertiesSet();
|
||||
|
||||
cache.putEntriesInCache(new BasicAclEntry[] {OBJECT_100_SCOTT, OBJECT_100_ROD});
|
||||
cache.putEntriesInCache(new BasicAclEntry[] {OBJECT_200_PETER});
|
||||
|
||||
// Check we can get them from cache again
|
||||
assertEquals(OBJECT_100_SCOTT, cache.getEntriesFromCache(new NamedEntityObjectIdentity("OBJECT", "100"))[0]);
|
||||
assertEquals(OBJECT_100_ROD, cache.getEntriesFromCache(new NamedEntityObjectIdentity("OBJECT", "100"))[1]);
|
||||
assertEquals(OBJECT_200_PETER, cache.getEntriesFromCache(new NamedEntityObjectIdentity("OBJECT", "200"))[0]);
|
||||
assertNull(cache.getEntriesFromCache(new NamedEntityObjectIdentity("OBJECT", "NOT_IN_CACHE")));
|
||||
|
||||
// Check after eviction we cannot get them from cache
|
||||
cache.removeEntriesFromCache(new NamedEntityObjectIdentity("OBJECT", "100"));
|
||||
assertNull(cache.getEntriesFromCache(new NamedEntityObjectIdentity("OBJECT", "100")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void startupDetectsMissingCache() throws Exception {
|
||||
EhCacheBasedAclEntryCache cache = new EhCacheBasedAclEntryCache();
|
||||
|
||||
try {
|
||||
cache.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
|
||||
Ehcache myCache = getCache();
|
||||
cache.setCache(myCache);
|
||||
assertEquals(myCache, cache.getCache());
|
||||
}
|
||||
}
|
||||
Vendored
-58
@@ -1,58 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.acl.basic.cache;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
import org.springframework.security.acl.basic.BasicAclEntry;
|
||||
import org.springframework.security.acl.basic.NamedEntityObjectIdentity;
|
||||
import org.springframework.security.acl.basic.SimpleAclEntry;
|
||||
|
||||
|
||||
/**
|
||||
* Tests {@link NullAclEntryCache}.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class NullAclEntryCacheTests extends TestCase {
|
||||
//~ Constructors ===================================================================================================
|
||||
|
||||
public NullAclEntryCacheTests() {
|
||||
super();
|
||||
}
|
||||
|
||||
public NullAclEntryCacheTests(String arg0) {
|
||||
super(arg0);
|
||||
}
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
public static void main(String[] args) {
|
||||
junit.textui.TestRunner.run(NullAclEntryCacheTests.class);
|
||||
}
|
||||
|
||||
public final void setUp() throws Exception {
|
||||
super.setUp();
|
||||
}
|
||||
|
||||
public void testCacheOperation() throws Exception {
|
||||
NullAclEntryCache cache = new NullAclEntryCache();
|
||||
cache.putEntriesInCache(new BasicAclEntry[] {new SimpleAclEntry()});
|
||||
cache.getEntriesFromCache(new NamedEntityObjectIdentity("not_used", "not_used"));
|
||||
cache.removeEntriesFromCache(new NamedEntityObjectIdentity("not_used", "not_used"));
|
||||
}
|
||||
}
|
||||
@@ -1,145 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.acl.basic.jdbc;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
import org.springframework.security.PopulatedDatabase;
|
||||
|
||||
import org.springframework.security.acl.basic.AclObjectIdentity;
|
||||
import org.springframework.security.acl.basic.BasicAclEntry;
|
||||
import org.springframework.security.acl.basic.NamedEntityObjectIdentity;
|
||||
|
||||
import org.springframework.jdbc.object.MappingSqlQuery;
|
||||
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
|
||||
|
||||
/**
|
||||
* Tests {@link JdbcDaoImpl}.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class JdbcDaoImplTests extends TestCase {
|
||||
//~ Static fields/initializers =====================================================================================
|
||||
|
||||
public static final String OBJECT_IDENTITY = "org.springframework.security.acl.DomainObject";
|
||||
|
||||
//~ Constructors ===================================================================================================
|
||||
|
||||
public JdbcDaoImplTests() {
|
||||
super();
|
||||
}
|
||||
|
||||
public JdbcDaoImplTests(String arg0) {
|
||||
super(arg0);
|
||||
}
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
public static void main(String[] args) {
|
||||
junit.textui.TestRunner.run(JdbcDaoImplTests.class);
|
||||
}
|
||||
|
||||
private JdbcDaoImpl makePopulatedJdbcDao() throws Exception {
|
||||
JdbcDaoImpl dao = new JdbcDaoImpl();
|
||||
dao.setDataSource(PopulatedDatabase.getDataSource());
|
||||
dao.afterPropertiesSet();
|
||||
|
||||
return dao;
|
||||
}
|
||||
|
||||
public final void setUp() throws Exception {
|
||||
super.setUp();
|
||||
}
|
||||
|
||||
public void testExceptionThrownIfBasicAclEntryClassNotFound()
|
||||
throws Exception {
|
||||
JdbcDaoImpl dao = makePopulatedJdbcDao();
|
||||
AclObjectIdentity identity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "7");
|
||||
|
||||
try {
|
||||
dao.getAcls(identity);
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testGetsEntriesWhichExistInDatabaseAndHaveAcls()
|
||||
throws Exception {
|
||||
JdbcDaoImpl dao = makePopulatedJdbcDao();
|
||||
AclObjectIdentity identity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "2");
|
||||
BasicAclEntry[] acls = dao.getAcls(identity);
|
||||
assertEquals(2, acls.length);
|
||||
}
|
||||
|
||||
public void testGetsEntriesWhichExistInDatabaseButHaveNoAcls()
|
||||
throws Exception {
|
||||
JdbcDaoImpl dao = makePopulatedJdbcDao();
|
||||
AclObjectIdentity identity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "5");
|
||||
BasicAclEntry[] acls = dao.getAcls(identity);
|
||||
assertEquals(1, acls.length);
|
||||
assertEquals(JdbcDaoImpl.RECIPIENT_USED_FOR_INHERITENCE_MARKER, acls[0].getRecipient());
|
||||
}
|
||||
|
||||
public void testGetsEntriesWhichHaveNoParent() throws Exception {
|
||||
JdbcDaoImpl dao = makePopulatedJdbcDao();
|
||||
AclObjectIdentity identity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "1");
|
||||
BasicAclEntry[] acls = dao.getAcls(identity);
|
||||
assertEquals(1, acls.length);
|
||||
assertNull(acls[0].getAclObjectParentIdentity());
|
||||
}
|
||||
|
||||
public void testGettersSetters() throws Exception {
|
||||
JdbcDaoImpl dao = makePopulatedJdbcDao();
|
||||
dao.setAclsByObjectIdentity(new MockMappingSqlQuery());
|
||||
assertNotNull(dao.getAclsByObjectIdentity());
|
||||
|
||||
dao.setAclsByObjectIdentityQuery("foo");
|
||||
assertEquals("foo", dao.getAclsByObjectIdentityQuery());
|
||||
|
||||
dao.setObjectPropertiesQuery("foobar");
|
||||
assertEquals("foobar", dao.getObjectPropertiesQuery());
|
||||
}
|
||||
|
||||
public void testNullReturnedIfEntityNotFound() throws Exception {
|
||||
JdbcDaoImpl dao = makePopulatedJdbcDao();
|
||||
AclObjectIdentity identity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "NOT_VALID_ID");
|
||||
BasicAclEntry[] result = dao.getAcls(identity);
|
||||
assertNull(result);
|
||||
}
|
||||
|
||||
public void testReturnsNullForUnNamedEntityObjectIdentity()
|
||||
throws Exception {
|
||||
JdbcDaoImpl dao = new JdbcDaoImpl();
|
||||
AclObjectIdentity identity = new AclObjectIdentity() {}
|
||||
;
|
||||
|
||||
assertNull(dao.getAcls(identity));
|
||||
}
|
||||
|
||||
//~ Inner Classes ==================================================================================================
|
||||
|
||||
private class MockMappingSqlQuery extends MappingSqlQuery {
|
||||
protected Object mapRow(ResultSet arg0, int arg1)
|
||||
throws SQLException {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
-312
@@ -1,312 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.acl.basic.jdbc;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
import org.springframework.security.PopulatedDatabase;
|
||||
|
||||
import org.springframework.security.acl.basic.AclObjectIdentity;
|
||||
import org.springframework.security.acl.basic.BasicAclEntry;
|
||||
import org.springframework.security.acl.basic.NamedEntityObjectIdentity;
|
||||
import org.springframework.security.acl.basic.SimpleAclEntry;
|
||||
|
||||
import org.springframework.dao.DataIntegrityViolationException;
|
||||
import org.springframework.dao.DataRetrievalFailureException;
|
||||
|
||||
import org.springframework.jdbc.object.MappingSqlQuery;
|
||||
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
|
||||
|
||||
/**
|
||||
* Tests {@link JdbcExtendedDaoImpl}.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class JdbcExtendedDaoImplTests extends TestCase {
|
||||
//~ Static fields/initializers =====================================================================================
|
||||
|
||||
public static final String OBJECT_IDENTITY = "org.springframework.security.acl.DomainObject";
|
||||
|
||||
//~ Constructors ===================================================================================================
|
||||
|
||||
public JdbcExtendedDaoImplTests() {
|
||||
super();
|
||||
}
|
||||
|
||||
public JdbcExtendedDaoImplTests(String arg0) {
|
||||
super(arg0);
|
||||
}
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
public static void main(String[] args) {
|
||||
junit.textui.TestRunner.run(JdbcExtendedDaoImplTests.class);
|
||||
}
|
||||
|
||||
private JdbcExtendedDaoImpl makePopulatedJdbcDao()
|
||||
throws Exception {
|
||||
JdbcExtendedDaoImpl dao = new JdbcExtendedDaoImpl();
|
||||
dao.setDataSource(PopulatedDatabase.getDataSource());
|
||||
dao.afterPropertiesSet();
|
||||
|
||||
return dao;
|
||||
}
|
||||
|
||||
public final void setUp() throws Exception {
|
||||
super.setUp();
|
||||
}
|
||||
|
||||
public void testChangeMask() throws Exception {
|
||||
JdbcExtendedDaoImpl dao = makePopulatedJdbcDao();
|
||||
AclObjectIdentity identity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "204");
|
||||
AclObjectIdentity parentIdentity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "1");
|
||||
|
||||
// Create a BasicAclEntry for this AclObjectIdentity
|
||||
SimpleAclEntry simpleAcl1 = new SimpleAclEntry("rod", identity, parentIdentity, SimpleAclEntry.CREATE);
|
||||
dao.create(simpleAcl1);
|
||||
|
||||
// Create another BasicAclEntry for this AclObjectIdentity
|
||||
SimpleAclEntry simpleAcl2 = new SimpleAclEntry("scott", identity, parentIdentity, SimpleAclEntry.READ);
|
||||
dao.create(simpleAcl2);
|
||||
|
||||
// Check creation was successful
|
||||
BasicAclEntry[] acls = dao.getAcls(identity);
|
||||
assertEquals(2, acls.length);
|
||||
assertEquals(SimpleAclEntry.CREATE, acls[0].getMask());
|
||||
assertEquals(SimpleAclEntry.READ, acls[1].getMask());
|
||||
|
||||
// Attempt to change mask
|
||||
dao.changeMask(identity, "rod", new Integer(SimpleAclEntry.ADMINISTRATION));
|
||||
dao.changeMask(identity, "scott", new Integer(SimpleAclEntry.NOTHING));
|
||||
acls = dao.getAcls(identity);
|
||||
assertEquals(2, acls.length);
|
||||
assertEquals("rod", acls[0].getRecipient());
|
||||
assertEquals(SimpleAclEntry.ADMINISTRATION, acls[0].getMask());
|
||||
assertEquals("scott", acls[1].getRecipient());
|
||||
assertEquals(SimpleAclEntry.NOTHING, acls[1].getMask());
|
||||
}
|
||||
|
||||
public void testChangeMaskThrowsExceptionWhenExistingRecordNotFound()
|
||||
throws Exception {
|
||||
JdbcExtendedDaoImpl dao = makePopulatedJdbcDao();
|
||||
AclObjectIdentity identity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "205");
|
||||
AclObjectIdentity parentIdentity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "1");
|
||||
|
||||
// Create at least one record for this AclObjectIdentity
|
||||
SimpleAclEntry simpleAcl1 = new SimpleAclEntry("rod", identity, parentIdentity, SimpleAclEntry.CREATE);
|
||||
dao.create(simpleAcl1);
|
||||
|
||||
// Attempt to change mask, but for a recipient we don't have
|
||||
try {
|
||||
dao.changeMask(identity, "scott", new Integer(SimpleAclEntry.ADMINISTRATION));
|
||||
fail("Should have thrown DataRetrievalFailureException");
|
||||
} catch (DataRetrievalFailureException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testConvertAclObjectIdentity() throws Exception {
|
||||
JdbcExtendedDaoImpl dao = makePopulatedJdbcDao();
|
||||
|
||||
try {
|
||||
dao.convertAclObjectIdentityToString(new AclObjectIdentity() {
|
||||
// not a NamedEntityObjectIdentity
|
||||
});
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testCreationOfIdentityThenAclInSeparateInvocations()
|
||||
throws Exception {
|
||||
JdbcExtendedDaoImpl dao = makePopulatedJdbcDao();
|
||||
AclObjectIdentity identity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "206");
|
||||
AclObjectIdentity parentIdentity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "1");
|
||||
|
||||
// Create just the object identity (NB: recipient and mask is null)
|
||||
SimpleAclEntry simpleAcl1 = new SimpleAclEntry();
|
||||
simpleAcl1.setAclObjectIdentity(identity);
|
||||
simpleAcl1.setAclObjectParentIdentity(parentIdentity);
|
||||
dao.create(simpleAcl1);
|
||||
|
||||
// Delete it
|
||||
dao.delete(identity);
|
||||
}
|
||||
|
||||
public void testDeletionOfAllRecipients() throws Exception {
|
||||
JdbcExtendedDaoImpl dao = makePopulatedJdbcDao();
|
||||
AclObjectIdentity identity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "203");
|
||||
|
||||
// Create a BasicAclEntry for this AclObjectIdentity
|
||||
SimpleAclEntry simpleAcl1 = new SimpleAclEntry("rod", identity, null, SimpleAclEntry.CREATE);
|
||||
dao.create(simpleAcl1);
|
||||
|
||||
// Create another BasicAclEntry for this AclObjectIdentity
|
||||
SimpleAclEntry simpleAcl2 = new SimpleAclEntry("scott", identity, null, SimpleAclEntry.READ);
|
||||
dao.create(simpleAcl2);
|
||||
|
||||
// Check creation was successful
|
||||
BasicAclEntry[] acls = dao.getAcls(identity);
|
||||
assertEquals(2, acls.length);
|
||||
|
||||
// Attempt deletion and check delete successful
|
||||
dao.delete(identity);
|
||||
assertNull(dao.getAcls(identity));
|
||||
}
|
||||
|
||||
public void testDeletionOfSpecificRecipient() throws Exception {
|
||||
JdbcExtendedDaoImpl dao = makePopulatedJdbcDao();
|
||||
AclObjectIdentity identity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "202");
|
||||
AclObjectIdentity parentIdentity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "1");
|
||||
|
||||
// Create a BasicAclEntry for this AclObjectIdentity
|
||||
SimpleAclEntry simpleAcl1 = new SimpleAclEntry("rod", identity, parentIdentity, SimpleAclEntry.CREATE);
|
||||
dao.create(simpleAcl1);
|
||||
|
||||
// Create another BasicAclEntry for this AclObjectIdentity
|
||||
SimpleAclEntry simpleAcl2 = new SimpleAclEntry("scott", identity, parentIdentity, SimpleAclEntry.READ);
|
||||
dao.create(simpleAcl2);
|
||||
|
||||
// Check creation was successful
|
||||
BasicAclEntry[] acls = dao.getAcls(identity);
|
||||
assertEquals(2, acls.length);
|
||||
|
||||
// Attempt deletion and check delete successful
|
||||
dao.delete(identity, "scott");
|
||||
acls = dao.getAcls(identity);
|
||||
assertEquals(1, acls.length);
|
||||
assertEquals(simpleAcl1.getRecipient(), acls[0].getRecipient());
|
||||
}
|
||||
|
||||
public void testGettersSetters() throws Exception {
|
||||
JdbcExtendedDaoImpl dao = makePopulatedJdbcDao();
|
||||
|
||||
assertNotNull(dao.getAclObjectIdentityDelete());
|
||||
dao.setAclObjectIdentityDelete(null);
|
||||
assertNull(dao.getAclObjectIdentityDelete());
|
||||
|
||||
assertNotNull(dao.getAclObjectIdentityInsert());
|
||||
dao.setAclObjectIdentityInsert(null);
|
||||
assertNull(dao.getAclObjectIdentityInsert());
|
||||
|
||||
assertNotNull(dao.getAclPermissionDelete());
|
||||
dao.setAclPermissionDelete(null);
|
||||
assertNull(dao.getAclPermissionDelete());
|
||||
|
||||
assertNotNull(dao.getAclPermissionInsert());
|
||||
dao.setAclPermissionInsert(null);
|
||||
assertNull(dao.getAclPermissionInsert());
|
||||
|
||||
assertNotNull(dao.getAclPermissionUpdate());
|
||||
dao.setAclPermissionUpdate(null);
|
||||
assertNull(dao.getAclPermissionUpdate());
|
||||
|
||||
assertNotNull(dao.getAclsByObjectIdentity());
|
||||
dao.setAclsByObjectIdentity(null);
|
||||
assertNull(dao.getAclsByObjectIdentity());
|
||||
|
||||
assertNotNull(dao.getLookupPermissionIdMapping());
|
||||
dao.setLookupPermissionIdMapping(null);
|
||||
assertNull(dao.getLookupPermissionIdMapping());
|
||||
|
||||
assertNotNull(dao.getAclObjectIdentityDeleteStatement());
|
||||
dao.setAclObjectIdentityDeleteStatement("SELECT ...");
|
||||
assertEquals("SELECT ...", dao.getAclObjectIdentityDeleteStatement());
|
||||
|
||||
assertNotNull(dao.getAclObjectIdentityInsertStatement());
|
||||
dao.setAclObjectIdentityInsertStatement("SELECT ...");
|
||||
assertEquals("SELECT ...", dao.getAclObjectIdentityInsertStatement());
|
||||
|
||||
assertNotNull(dao.getAclPermissionDeleteStatement());
|
||||
dao.setAclPermissionDeleteStatement("SELECT ...");
|
||||
assertEquals("SELECT ...", dao.getAclPermissionDeleteStatement());
|
||||
|
||||
assertNotNull(dao.getAclPermissionInsertStatement());
|
||||
dao.setAclPermissionInsertStatement("SELECT ...");
|
||||
assertEquals("SELECT ...", dao.getAclPermissionInsertStatement());
|
||||
|
||||
assertNotNull(dao.getAclPermissionUpdateStatement());
|
||||
dao.setAclPermissionUpdateStatement("SELECT ...");
|
||||
assertEquals("SELECT ...", dao.getAclPermissionUpdateStatement());
|
||||
|
||||
assertNotNull(dao.getAclsByObjectIdentityQuery());
|
||||
dao.setAclsByObjectIdentityQuery("SELECT ...");
|
||||
assertEquals("SELECT ...", dao.getAclsByObjectIdentityQuery());
|
||||
|
||||
assertNotNull(dao.getLookupPermissionIdQuery());
|
||||
dao.setLookupPermissionIdQuery("SELECT ...");
|
||||
assertEquals("SELECT ...", dao.getLookupPermissionIdQuery());
|
||||
}
|
||||
|
||||
public void testNormalCreationAndDuplicateDetection()
|
||||
throws Exception {
|
||||
JdbcExtendedDaoImpl dao = makePopulatedJdbcDao();
|
||||
AclObjectIdentity identity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "200");
|
||||
AclObjectIdentity parentIdentity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "1");
|
||||
|
||||
// Create a BasicAclEntry for this AclObjectIdentity
|
||||
SimpleAclEntry simpleAcl1 = new SimpleAclEntry("rod", identity, parentIdentity, SimpleAclEntry.CREATE);
|
||||
dao.create(simpleAcl1);
|
||||
|
||||
// Create another BasicAclEntry for this AclObjectIdentity
|
||||
SimpleAclEntry simpleAcl2 = new SimpleAclEntry("scott", identity, parentIdentity, SimpleAclEntry.READ);
|
||||
dao.create(simpleAcl2);
|
||||
|
||||
// Check creation was successful
|
||||
BasicAclEntry[] acls = dao.getAcls(identity);
|
||||
assertEquals(2, acls.length);
|
||||
assertEquals(simpleAcl1.getRecipient(), acls[0].getRecipient());
|
||||
assertEquals(simpleAcl1.getMask(), acls[0].getMask());
|
||||
assertEquals(simpleAcl2.getRecipient(), acls[1].getRecipient());
|
||||
assertEquals(simpleAcl2.getMask(), acls[1].getMask());
|
||||
|
||||
// Check it rejects an attempt to create another identical entry
|
||||
try {
|
||||
dao.create(simpleAcl1);
|
||||
fail("Should have thrown DataIntegrityViolationException");
|
||||
} catch (DataIntegrityViolationException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testRejectsInvalidParent() throws Exception {
|
||||
JdbcExtendedDaoImpl dao = makePopulatedJdbcDao();
|
||||
AclObjectIdentity identity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "201");
|
||||
AclObjectIdentity parentIdentity = new NamedEntityObjectIdentity(OBJECT_IDENTITY, "987987987987986");
|
||||
SimpleAclEntry simpleAcl = new SimpleAclEntry("rod", identity, parentIdentity, SimpleAclEntry.CREATE);
|
||||
|
||||
try {
|
||||
dao.create(simpleAcl);
|
||||
fail("Should have thrown DataRetrievalFailureException");
|
||||
} catch (DataRetrievalFailureException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
//~ Inner Classes ==================================================================================================
|
||||
|
||||
private class MockMappingSqlQuery extends MappingSqlQuery {
|
||||
protected Object mapRow(ResultSet arg0, int arg1)
|
||||
throws SQLException {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
-373
@@ -1,373 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.afterinvocation;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Vector;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
import org.springframework.security.AuthorizationServiceException;
|
||||
import org.springframework.security.ConfigAttribute;
|
||||
import org.springframework.security.MockAclManager;
|
||||
import org.springframework.security.SecurityConfig;
|
||||
import org.springframework.security.acl.AclEntry;
|
||||
import org.springframework.security.acl.AclManager;
|
||||
import org.springframework.security.acl.basic.MockAclObjectIdentity;
|
||||
import org.springframework.security.acl.basic.SimpleAclEntry;
|
||||
import org.springframework.security.providers.UsernamePasswordAuthenticationToken;
|
||||
import org.springframework.security.util.SimpleMethodInvocation;
|
||||
|
||||
|
||||
/**
|
||||
* Tests {@link BasicAclEntryAfterInvocationCollectionFilteringProvider}.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class BasicAclEntryAfterInvocationCollectionFilteringProviderTests extends TestCase {
|
||||
//~ Constructors ===================================================================================================
|
||||
|
||||
public BasicAclEntryAfterInvocationCollectionFilteringProviderTests() {
|
||||
super();
|
||||
}
|
||||
|
||||
public BasicAclEntryAfterInvocationCollectionFilteringProviderTests(String arg0) {
|
||||
super(arg0);
|
||||
}
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
public void testCorrectOperationWhenPrincipalHasIncorrectPermissionToDomainObject()
|
||||
throws Exception {
|
||||
// Create an AclManager, granting scott only ADMINISTRATION rights
|
||||
AclManager aclManager = new MockAclManager("belmont", "scott",
|
||||
new AclEntry[] {
|
||||
new SimpleAclEntry("scott", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION)
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationCollectionFilteringProvider provider = new BasicAclEntryAfterInvocationCollectionFilteringProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create a Collection containing many items
|
||||
List list = new Vector();
|
||||
list.add("sydney");
|
||||
list.add("melbourne");
|
||||
list.add("belmont");
|
||||
list.add("brisbane");
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("scott", "NOT_USED");
|
||||
|
||||
// Filter
|
||||
List filteredList = (List) provider.decide(auth, new SimpleMethodInvocation(),
|
||||
SecurityConfig.createList("AFTER_ACL_COLLECTION_READ"), list);
|
||||
|
||||
assertEquals(0, filteredList.size());
|
||||
}
|
||||
|
||||
public void testCorrectOperationWhenPrincipalHasNoPermissionToDomainObject()
|
||||
throws Exception {
|
||||
// Create an AclManager
|
||||
AclManager aclManager = new MockAclManager("belmont", "rod",
|
||||
new AclEntry[] {
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationCollectionFilteringProvider provider = new BasicAclEntryAfterInvocationCollectionFilteringProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create a Collection containing many items, which only "belmont"
|
||||
// should remain in after filtering by provider
|
||||
List list = new Vector();
|
||||
list.add("sydney");
|
||||
list.add("melbourne");
|
||||
list.add("belmont");
|
||||
list.add("brisbane");
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("scott", "NOT_USED");
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("AFTER_ACL_COLLECTION_READ");
|
||||
|
||||
// Filter
|
||||
List filteredList = (List) provider.decide(auth, new SimpleMethodInvocation(), attr, list);
|
||||
|
||||
assertEquals(0, filteredList.size());
|
||||
}
|
||||
|
||||
public void testCorrectOperationWhenPrincipalIsAuthorised()
|
||||
throws Exception {
|
||||
// Create an AclManager
|
||||
AclManager aclManager = new MockAclManager("belmont", "rod",
|
||||
new AclEntry[] {
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationCollectionFilteringProvider provider = new BasicAclEntryAfterInvocationCollectionFilteringProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
assertEquals(aclManager, provider.getAclManager());
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create a Collection containing many items, which only "belmont"
|
||||
// should remain in after filtering by provider
|
||||
List list = new Vector();
|
||||
list.add("sydney");
|
||||
list.add("melbourne");
|
||||
list.add("belmont");
|
||||
list.add("brisbane");
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("rod", "NOT_USED");
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("AFTER_ACL_COLLECTION_READ");
|
||||
|
||||
// Filter
|
||||
List filteredList = (List) provider.decide(auth, new SimpleMethodInvocation(), attr, list);
|
||||
|
||||
assertEquals(1, filteredList.size());
|
||||
assertEquals("belmont", filteredList.get(0));
|
||||
}
|
||||
|
||||
public void testCorrectOperationWhenReturnedObjectIsArray()
|
||||
throws Exception {
|
||||
// Create an AclManager
|
||||
AclManager aclManager = new MockAclManager("belmont", "rod",
|
||||
new AclEntry[] {
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationCollectionFilteringProvider provider = new BasicAclEntryAfterInvocationCollectionFilteringProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
assertEquals(aclManager, provider.getAclManager());
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create a Collection containing many items, which only "belmont"
|
||||
// should remain in after filtering by provider
|
||||
String[] list = new String[4];
|
||||
list[0] = "sydney";
|
||||
list[1] = "melbourne";
|
||||
list[2] = "belmont";
|
||||
list[3] = "brisbane";
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("rod", "NOT_USED");
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("AFTER_ACL_COLLECTION_READ");
|
||||
|
||||
// Filter
|
||||
String[] filteredList = (String[]) provider.decide(auth, new SimpleMethodInvocation(), attr, list);
|
||||
|
||||
assertEquals(1, filteredList.length);
|
||||
assertEquals("belmont", filteredList[0]);
|
||||
}
|
||||
|
||||
public void testDetectsIfReturnedObjectIsNotACollection()
|
||||
throws Exception {
|
||||
// Create an AclManager
|
||||
AclManager aclManager = new MockAclManager("belmont", "rod",
|
||||
new AclEntry[] {
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE),
|
||||
new MockAclEntry()
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationCollectionFilteringProvider provider = new BasicAclEntryAfterInvocationCollectionFilteringProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("rod", "NOT_USED");
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("AFTER_ACL_COLLECTION_READ");
|
||||
|
||||
// Filter
|
||||
try {
|
||||
provider.decide(auth, new SimpleMethodInvocation(), attr, new String("RETURN_OBJECT_NOT_COLLECTION"));
|
||||
fail("Should have thrown AuthorizationServiceException");
|
||||
} catch (AuthorizationServiceException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testGrantsAccessIfReturnedObjectIsNull()
|
||||
throws Exception {
|
||||
// Create an AclManager
|
||||
AclManager aclManager = new MockAclManager("belmont", "rod",
|
||||
new AclEntry[] {
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE),
|
||||
new MockAclEntry()
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationCollectionFilteringProvider provider = new BasicAclEntryAfterInvocationCollectionFilteringProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("rod", "NOT_USED");
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("AFTER_ACL_COLLECTION_READ");
|
||||
|
||||
// Filter
|
||||
List filteredList = (List) provider.decide(auth, new SimpleMethodInvocation(), attr, null);
|
||||
|
||||
assertNull(filteredList);
|
||||
}
|
||||
|
||||
public void testRespectsModificationsToProcessConfigAttribute() throws Exception {
|
||||
// Create an AclManager
|
||||
AclManager aclManager = new MockAclManager("sydney", "rod",
|
||||
new AclEntry[] {
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new MockAclEntry()
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationCollectionFilteringProvider provider = new BasicAclEntryAfterInvocationCollectionFilteringProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
assertEquals("AFTER_ACL_COLLECTION_READ", provider.getProcessConfigAttribute());
|
||||
provider.setProcessConfigAttribute("AFTER_ACL_COLLECTION_ADMIN");
|
||||
assertEquals("AFTER_ACL_COLLECTION_ADMIN", provider.getProcessConfigAttribute());
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create a Collection containing many items, which only "sydney"
|
||||
// should remain in after filtering by provider
|
||||
List list = new Vector();
|
||||
list.add("sydney");
|
||||
list.add("melbourne");
|
||||
list.add("belmont");
|
||||
list.add("brisbane");
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("rod", "NOT_USED");
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("AFTER_ACL_COLLECTION_READ");
|
||||
|
||||
// As no matching config attrib, ensure provider doesn't change list
|
||||
assertEquals(4, ((List) provider.decide(auth, new SimpleMethodInvocation(), attr, list)).size());
|
||||
|
||||
// Filter, this time with the conf attrib provider setup to answer
|
||||
attr = SecurityConfig.createList("AFTER_ACL_COLLECTION_ADMIN");
|
||||
|
||||
List filteredList = (List) provider.decide(auth, new SimpleMethodInvocation(), attr, list);
|
||||
|
||||
assertEquals(1, filteredList.size());
|
||||
assertEquals("sydney", filteredList.get(0));
|
||||
}
|
||||
|
||||
public void testRespectsModificationsToRequirePermissions()
|
||||
throws Exception {
|
||||
// Create an AclManager
|
||||
AclManager aclManager = new MockAclManager("sydney", "rod",
|
||||
new AclEntry[] {
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new MockAclEntry()
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationCollectionFilteringProvider provider = new BasicAclEntryAfterInvocationCollectionFilteringProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
assertEquals(SimpleAclEntry.READ, provider.getRequirePermission()[0]);
|
||||
provider.setRequirePermission(new int[] {SimpleAclEntry.ADMINISTRATION});
|
||||
assertEquals(SimpleAclEntry.ADMINISTRATION, provider.getRequirePermission()[0]);
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create a Collection containing many items, which only "sydney"
|
||||
// should remain in after filtering by provider
|
||||
List list = new Vector();
|
||||
list.add("sydney");
|
||||
list.add("melbourne");
|
||||
list.add("belmont");
|
||||
list.add("brisbane");
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("rod", "NOT_USED");
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("AFTER_ACL_COLLECTION_READ");
|
||||
|
||||
// Filter
|
||||
List filteredList = (List) provider.decide(auth, new SimpleMethodInvocation(), attr, list);
|
||||
|
||||
assertEquals(1, filteredList.size());
|
||||
assertEquals("sydney", filteredList.get(0));
|
||||
}
|
||||
|
||||
public void testStartupDetectsMissingAclManager() throws Exception {
|
||||
BasicAclEntryAfterInvocationCollectionFilteringProvider provider = new BasicAclEntryAfterInvocationCollectionFilteringProvider();
|
||||
|
||||
try {
|
||||
provider.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertEquals("An aclManager is mandatory", expected.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
public void testStartupDetectsMissingProcessConfigAttribute()
|
||||
throws Exception {
|
||||
BasicAclEntryAfterInvocationCollectionFilteringProvider provider = new BasicAclEntryAfterInvocationCollectionFilteringProvider();
|
||||
AclManager aclManager = new MockAclManager("sydney", "rod",
|
||||
new AclEntry[] {
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new MockAclEntry()
|
||||
});
|
||||
provider.setAclManager(aclManager);
|
||||
|
||||
provider.setProcessConfigAttribute(null);
|
||||
|
||||
try {
|
||||
provider.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertEquals("A processConfigAttribute is mandatory", expected.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
public void testStartupDetectsMissingRequirePermission()
|
||||
throws Exception {
|
||||
BasicAclEntryAfterInvocationCollectionFilteringProvider provider = new BasicAclEntryAfterInvocationCollectionFilteringProvider();
|
||||
AclManager aclManager = new MockAclManager("sydney", "rod",
|
||||
new AclEntry[] {
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new MockAclEntry()
|
||||
});
|
||||
provider.setAclManager(aclManager);
|
||||
|
||||
provider.setRequirePermission(null);
|
||||
|
||||
try {
|
||||
provider.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertEquals("One or more requirePermission entries is mandatory", expected.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
public void testSupportsAnything() {
|
||||
assertTrue(new BasicAclEntryAfterInvocationCollectionFilteringProvider().supports(String.class));
|
||||
}
|
||||
|
||||
//~ Inner Classes ==================================================================================================
|
||||
|
||||
private class MockAclEntry implements AclEntry {
|
||||
// just so AclTag iterates some different types of AclEntrys
|
||||
}
|
||||
}
|
||||
-257
@@ -1,257 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.afterinvocation;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
import org.springframework.security.AccessDeniedException;
|
||||
import org.springframework.security.ConfigAttribute;
|
||||
import org.springframework.security.ConfigAttributeDefinition;
|
||||
import org.springframework.security.MockAclManager;
|
||||
import org.springframework.security.SecurityConfig;
|
||||
import org.springframework.security.acl.AclEntry;
|
||||
import org.springframework.security.acl.AclManager;
|
||||
import org.springframework.security.acl.basic.MockAclObjectIdentity;
|
||||
import org.springframework.security.acl.basic.SimpleAclEntry;
|
||||
|
||||
import org.springframework.security.providers.UsernamePasswordAuthenticationToken;
|
||||
|
||||
import org.springframework.security.util.SimpleMethodInvocation;
|
||||
|
||||
|
||||
/**
|
||||
* Tests {@link BasicAclEntryAfterInvocationProvider}.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class BasicAclEntryAfterInvocationProviderTests extends TestCase {
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
public void testCorrectOperationWhenPrincipalHasIncorrectPermissionToDomainObject()
|
||||
throws Exception {
|
||||
// Create an AclManager, granting scott only ADMINISTRATION rights
|
||||
AclManager aclManager = new MockAclManager("belmont", "scott",
|
||||
new AclEntry[]{
|
||||
new SimpleAclEntry("scott", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION)
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationProvider provider = new BasicAclEntryAfterInvocationProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("scott", "NOT_USED");
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("AFTER_ACL_READ");
|
||||
|
||||
try {
|
||||
provider.decide(auth, new SimpleMethodInvocation(), attr, "belmont");
|
||||
fail("Should have thrown AccessDeniedException");
|
||||
} catch (AccessDeniedException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testCorrectOperationWhenPrincipalHasNoPermissionToDomainObject()
|
||||
throws Exception {
|
||||
// Create an AclManager
|
||||
AclManager aclManager = new MockAclManager("belmont", "rod",
|
||||
new AclEntry[]{
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationProvider provider = new BasicAclEntryAfterInvocationProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("scott", "NOT_USED");
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("AFTER_ACL_READ");
|
||||
|
||||
try {
|
||||
provider.decide(auth, new SimpleMethodInvocation(), attr, "belmont");
|
||||
fail("Should have thrown AccessDeniedException");
|
||||
} catch (AccessDeniedException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testCorrectOperationWhenPrincipalIsAuthorised()
|
||||
throws Exception {
|
||||
// Create an AclManager
|
||||
AclManager aclManager = new MockAclManager("belmont", "rod",
|
||||
new AclEntry[]{
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationProvider provider = new BasicAclEntryAfterInvocationProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
assertEquals(aclManager, provider.getAclManager());
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("rod", "NOT_USED");
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("AFTER_ACL_READ");
|
||||
|
||||
// Filter
|
||||
assertEquals("belmont", provider.decide(auth, new SimpleMethodInvocation(), attr, "belmont"));
|
||||
}
|
||||
|
||||
public void testGrantsAccessIfReturnedObjectIsNull()
|
||||
throws Exception {
|
||||
// Create an AclManager
|
||||
AclManager aclManager = new MockAclManager("belmont", "rod",
|
||||
new AclEntry[]{
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE),
|
||||
new MockAclEntry()
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationProvider provider = new BasicAclEntryAfterInvocationProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("rod", "NOT_USED");
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("AFTER_ACL_READ");
|
||||
|
||||
// Filter
|
||||
assertNull(provider.decide(auth, new SimpleMethodInvocation(), attr, null));
|
||||
}
|
||||
|
||||
public void testRespectsModificationsToProcessConfigAttribute()
|
||||
throws Exception {
|
||||
// Create an AclManager
|
||||
AclManager aclManager = new MockAclManager("sydney", "rod",
|
||||
new AclEntry[]{
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new MockAclEntry()
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationProvider provider = new BasicAclEntryAfterInvocationProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
assertEquals("AFTER_ACL_READ", provider.getProcessConfigAttribute());
|
||||
provider.setProcessConfigAttribute("AFTER_ACL_ADMIN");
|
||||
assertEquals("AFTER_ACL_ADMIN", provider.getProcessConfigAttribute());
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("rod", "NOT_USED");
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("AFTER_ACL_READ");
|
||||
|
||||
// As no matching config attrib, ensure provider returns original obj
|
||||
assertEquals("sydney", provider.decide(auth, new SimpleMethodInvocation(), attr, "sydney"));
|
||||
|
||||
// Filter, this time with the conf attrib provider setup to answer
|
||||
attr = SecurityConfig.createList("AFTER_ACL_ADMIN");
|
||||
assertEquals("sydney", provider.decide(auth, new SimpleMethodInvocation(), attr, "sydney"));
|
||||
}
|
||||
|
||||
public void testRespectsModificationsToRequirePermissions()
|
||||
throws Exception {
|
||||
// Create an AclManager
|
||||
AclManager aclManager = new MockAclManager("sydney", "rod",
|
||||
new AclEntry[]{
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new MockAclEntry()
|
||||
});
|
||||
|
||||
BasicAclEntryAfterInvocationProvider provider = new BasicAclEntryAfterInvocationProvider();
|
||||
provider.setAclManager(aclManager);
|
||||
assertEquals(SimpleAclEntry.READ, provider.getRequirePermission()[0]);
|
||||
provider.setRequirePermission(new int[]{SimpleAclEntry.ADMINISTRATION});
|
||||
assertEquals(SimpleAclEntry.ADMINISTRATION, provider.getRequirePermission()[0]);
|
||||
provider.afterPropertiesSet();
|
||||
|
||||
// Create the Authentication and Config Attribs we'll be presenting
|
||||
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken("rod", "NOT_USED");
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("AFTER_ACL_READ");
|
||||
|
||||
// Filter
|
||||
assertEquals("sydney", provider.decide(auth, new SimpleMethodInvocation(), attr, "sydney"));
|
||||
}
|
||||
|
||||
public void testStartupDetectsMissingAclManager() throws Exception {
|
||||
BasicAclEntryAfterInvocationProvider provider = new BasicAclEntryAfterInvocationProvider();
|
||||
|
||||
try {
|
||||
provider.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertEquals("An aclManager is mandatory", expected.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
public void testStartupDetectsMissingProcessConfigAttribute()
|
||||
throws Exception {
|
||||
BasicAclEntryAfterInvocationProvider provider = new BasicAclEntryAfterInvocationProvider();
|
||||
AclManager aclManager = new MockAclManager("sydney", "rod",
|
||||
new AclEntry[] {
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new MockAclEntry()
|
||||
});
|
||||
provider.setAclManager(aclManager);
|
||||
|
||||
provider.setProcessConfigAttribute(null);
|
||||
|
||||
try {
|
||||
provider.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertEquals("A processConfigAttribute is mandatory", expected.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
public void testStartupDetectsMissingRequirePermission()
|
||||
throws Exception {
|
||||
BasicAclEntryAfterInvocationProvider provider = new BasicAclEntryAfterInvocationProvider();
|
||||
AclManager aclManager = new MockAclManager("sydney", "rod",
|
||||
new AclEntry[] {
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new MockAclEntry()
|
||||
});
|
||||
provider.setAclManager(aclManager);
|
||||
|
||||
provider.setRequirePermission(null);
|
||||
|
||||
try {
|
||||
provider.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertEquals("One or more requirePermission entries is mandatory", expected.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
public void testSupportsAnything() {
|
||||
assertTrue(new BasicAclEntryAfterInvocationProvider().supports(String.class));
|
||||
}
|
||||
|
||||
//~ Inner Classes ==================================================================================================
|
||||
|
||||
private class MockAclEntry implements AclEntry {
|
||||
// just so AclTag iterates some different types of AclEntrys
|
||||
}
|
||||
}
|
||||
@@ -1,472 +0,0 @@
|
||||
/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
|
||||
*
|
||||
* Licensed 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.springframework.security.vote;
|
||||
|
||||
import java.lang.reflect.Method;
|
||||
import java.util.List;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
import org.aopalliance.intercept.MethodInvocation;
|
||||
import org.aspectj.lang.JoinPoint;
|
||||
import org.springframework.security.AuthorizationServiceException;
|
||||
import org.springframework.security.ConfigAttribute;
|
||||
import org.springframework.security.MockAclManager;
|
||||
import org.springframework.security.SecurityConfig;
|
||||
import org.springframework.security.acl.AclEntry;
|
||||
import org.springframework.security.acl.AclManager;
|
||||
import org.springframework.security.acl.basic.MockAclObjectIdentity;
|
||||
import org.springframework.security.acl.basic.SimpleAclEntry;
|
||||
import org.springframework.security.providers.UsernamePasswordAuthenticationToken;
|
||||
import org.springframework.security.util.SimpleMethodInvocation;
|
||||
|
||||
/**
|
||||
* Tests {@link BasicAclEntryVoter}.
|
||||
*
|
||||
* @author Ben Alex
|
||||
* @version $Id$
|
||||
*/
|
||||
public class BasicAclEntryVoterTests extends TestCase {
|
||||
//~ Constructors ===================================================================================================
|
||||
|
||||
public BasicAclEntryVoterTests() {
|
||||
super();
|
||||
}
|
||||
|
||||
public BasicAclEntryVoterTests(String arg0) {
|
||||
super(arg0);
|
||||
}
|
||||
|
||||
//~ Methods ========================================================================================================
|
||||
|
||||
private MethodInvocation getMethodInvocation(SomeDomainObject domainObject)
|
||||
throws Exception {
|
||||
Class clazz = SomeDomainObjectManager.class;
|
||||
Method method = clazz.getMethod("someServiceMethod", new Class[] {SomeDomainObject.class});
|
||||
|
||||
return new SimpleMethodInvocation(new SomeDomainObjectManager(), method, new Object[] {domainObject});
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
junit.textui.TestRunner.run(BasicAclEntryVoterTests.class);
|
||||
}
|
||||
|
||||
public final void setUp() throws Exception {
|
||||
super.setUp();
|
||||
}
|
||||
|
||||
public void testNormalOperation() throws Exception {
|
||||
// Setup a domain object subject of this test
|
||||
SomeDomainObject domainObject = new SomeDomainObject("foo");
|
||||
|
||||
// Setup an AclManager
|
||||
AclManager aclManager = new MockAclManager(domainObject, "rod",
|
||||
new AclEntry[]{
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
// Wire up a voter
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
voter.setAclManager(aclManager);
|
||||
assertEquals(aclManager, voter.getAclManager());
|
||||
voter.setProcessConfigAttribute("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
assertEquals("FOO_ADMIN_OR_WRITE_ACCESS", voter.getProcessConfigAttribute());
|
||||
voter.setRequirePermission(new int[]{SimpleAclEntry.ADMINISTRATION, SimpleAclEntry.WRITE});
|
||||
assertEquals(2, voter.getRequirePermission().length);
|
||||
voter.setProcessDomainObjectClass(SomeDomainObject.class);
|
||||
assertEquals(SomeDomainObject.class, voter.getProcessDomainObjectClass());
|
||||
voter.afterPropertiesSet();
|
||||
|
||||
// Wire up an invocation to be voted on
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
|
||||
// Setup a MockMethodInvocation, so voter can retrieve domainObject
|
||||
MethodInvocation mi = getMethodInvocation(domainObject);
|
||||
|
||||
assertEquals(AccessDecisionVoter.ACCESS_GRANTED,
|
||||
voter.vote(new UsernamePasswordAuthenticationToken("rod", null), mi, attr));
|
||||
}
|
||||
|
||||
public void testOnlySupportsMethodInvocationAndJoinPoint() {
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
assertTrue(voter.supports(MethodInvocation.class));
|
||||
assertTrue(voter.supports(JoinPoint.class));
|
||||
assertFalse(voter.supports(String.class));
|
||||
}
|
||||
|
||||
public void testStartupRejectsMissingAclManager() throws Exception {
|
||||
// Wire up a voter
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
voter.setProcessConfigAttribute("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
voter.setRequirePermission(new int[] {SimpleAclEntry.ADMINISTRATION, SimpleAclEntry.WRITE});
|
||||
voter.setProcessDomainObjectClass(SomeDomainObject.class);
|
||||
|
||||
try {
|
||||
voter.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testStartupRejectsMissingProcessConfigAttribute()
|
||||
throws Exception {
|
||||
AclManager aclManager = new MockAclManager("domain1", "rod",
|
||||
new AclEntry[] {
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
// Wire up a voter
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
voter.setAclManager(aclManager);
|
||||
voter.setRequirePermission(new int[] {SimpleAclEntry.ADMINISTRATION, SimpleAclEntry.WRITE});
|
||||
voter.setProcessDomainObjectClass(SomeDomainObject.class);
|
||||
|
||||
try {
|
||||
voter.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testStartupRejectsMissingProcessDomainObjectClass()
|
||||
throws Exception {
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
|
||||
try {
|
||||
voter.setProcessDomainObjectClass(null);
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testStartupRejectsMissingRequirePermission()
|
||||
throws Exception {
|
||||
AclManager aclManager = new MockAclManager("domain1", "rod",
|
||||
new AclEntry[] {
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
// Wire up a voter
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
voter.setAclManager(aclManager);
|
||||
voter.setProcessConfigAttribute("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
voter.setProcessDomainObjectClass(SomeDomainObject.class);
|
||||
|
||||
try {
|
||||
voter.afterPropertiesSet();
|
||||
fail("Should have thrown IllegalArgumentException");
|
||||
} catch (IllegalArgumentException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testSupportsConfigAttribute() {
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
voter.setProcessConfigAttribute("foobar");
|
||||
assertTrue(voter.supports(new SecurityConfig("foobar")));
|
||||
}
|
||||
|
||||
public void testVoterAbstainsIfDomainObjectIsNull()
|
||||
throws Exception {
|
||||
// Setup a domain object subject of this test
|
||||
SomeDomainObject domainObject = new SomeDomainObject("foo");
|
||||
|
||||
// Setup an AclManager
|
||||
AclManager aclManager = new MockAclManager(domainObject, "rod",
|
||||
new AclEntry[]{
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
// Wire up a voter
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
voter.setAclManager(aclManager);
|
||||
voter.setProcessConfigAttribute("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
voter.setRequirePermission(new int[]{SimpleAclEntry.ADMINISTRATION, SimpleAclEntry.WRITE});
|
||||
voter.setProcessDomainObjectClass(SomeDomainObject.class);
|
||||
voter.afterPropertiesSet();
|
||||
|
||||
// Wire up an invocation to be voted on
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("A_DIFFERENT_ATTRIBUTE");
|
||||
|
||||
// Setup a MockMethodInvocation, so voter can retrieve domainObject
|
||||
MethodInvocation mi = getMethodInvocation(domainObject);
|
||||
|
||||
assertEquals(AccessDecisionVoter.ACCESS_ABSTAIN,
|
||||
voter.vote(new UsernamePasswordAuthenticationToken("rod", null), mi, attr));
|
||||
}
|
||||
|
||||
public void testVoterAbstainsIfNotMatchingConfigAttribute()
|
||||
throws Exception {
|
||||
// Setup a domain object subject of this test
|
||||
SomeDomainObject domainObject = null;
|
||||
|
||||
// Setup an AclManager
|
||||
AclManager aclManager = new MockAclManager(domainObject, "rod",
|
||||
new AclEntry[]{
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
// Wire up a voter
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
voter.setAclManager(aclManager);
|
||||
voter.setProcessConfigAttribute("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
voter.setRequirePermission(new int[]{SimpleAclEntry.ADMINISTRATION, SimpleAclEntry.WRITE});
|
||||
voter.setProcessDomainObjectClass(SomeDomainObject.class);
|
||||
voter.afterPropertiesSet();
|
||||
|
||||
// Wire up an invocation to be voted on
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
|
||||
// Setup a MockMethodInvocation, so voter can retrieve domainObject
|
||||
MethodInvocation mi = getMethodInvocation(domainObject);
|
||||
|
||||
assertEquals(AccessDecisionVoter.ACCESS_ABSTAIN,
|
||||
voter.vote(new UsernamePasswordAuthenticationToken("rod", null), mi, attr));
|
||||
}
|
||||
|
||||
public void testVoterCanDenyAccessBasedOnInternalMethodOfDomainObject()
|
||||
throws Exception {
|
||||
// Setup a domain object subject of this test
|
||||
SomeDomainObject domainObject = new SomeDomainObject("foo");
|
||||
|
||||
// Setup an AclManager
|
||||
AclManager aclManager = new MockAclManager(domainObject.getParent(), "rod",
|
||||
new AclEntry[]{
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
// Wire up a voter
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
voter.setAclManager(aclManager);
|
||||
voter.setProcessConfigAttribute("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
voter.setRequirePermission(new int[]{SimpleAclEntry.ADMINISTRATION, SimpleAclEntry.WRITE});
|
||||
voter.setProcessDomainObjectClass(SomeDomainObject.class);
|
||||
voter.setInternalMethod("getParent");
|
||||
voter.afterPropertiesSet();
|
||||
|
||||
// Wire up an invocation to be voted on
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
|
||||
// Setup a MockMethodInvocation, so voter can retrieve domainObject
|
||||
MethodInvocation mi = getMethodInvocation(domainObject);
|
||||
|
||||
assertEquals(AccessDecisionVoter.ACCESS_DENIED,
|
||||
voter.vote(new UsernamePasswordAuthenticationToken("rod", null), mi, attr));
|
||||
}
|
||||
|
||||
public void testVoterCanDenyAccessIfPrincipalHasNoPermissionsAtAllToDomainObject()
|
||||
throws Exception {
|
||||
// Setup a domain object subject of this test
|
||||
SomeDomainObject domainObject = new SomeDomainObject("foo");
|
||||
|
||||
// Setup an AclManager
|
||||
AclManager aclManager = new MockAclManager(domainObject, "rod",
|
||||
new AclEntry[]{
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
// Wire up a voter
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
voter.setAclManager(aclManager);
|
||||
voter.setProcessConfigAttribute("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
voter.setRequirePermission(new int[]{SimpleAclEntry.ADMINISTRATION, SimpleAclEntry.WRITE});
|
||||
voter.setProcessDomainObjectClass(SomeDomainObject.class);
|
||||
voter.setInternalMethod("getParent");
|
||||
voter.afterPropertiesSet();
|
||||
|
||||
// Wire up an invocation to be voted on
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
|
||||
// Setup a MockMethodInvocation, so voter can retrieve domainObject
|
||||
MethodInvocation mi = getMethodInvocation(domainObject);
|
||||
|
||||
// NB: scott is the principal, not rod
|
||||
assertEquals(AccessDecisionVoter.ACCESS_DENIED,
|
||||
voter.vote(new UsernamePasswordAuthenticationToken("scott", null), mi, attr));
|
||||
}
|
||||
|
||||
public void testVoterCanGrantAccessBasedOnInternalMethodOfDomainObject()
|
||||
throws Exception {
|
||||
// Setup a domain object subject of this test
|
||||
SomeDomainObject domainObject = new SomeDomainObject("foo");
|
||||
|
||||
// Setup an AclManager
|
||||
AclManager aclManager = new MockAclManager(domainObject.getParent(), "rod",
|
||||
new AclEntry[]{
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
// Wire up a voter
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
voter.setAclManager(aclManager);
|
||||
voter.setProcessConfigAttribute("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
voter.setRequirePermission(new int[]{SimpleAclEntry.ADMINISTRATION, SimpleAclEntry.WRITE});
|
||||
voter.setProcessDomainObjectClass(SomeDomainObject.class);
|
||||
voter.setInternalMethod("getParent");
|
||||
assertEquals("getParent", voter.getInternalMethod());
|
||||
voter.afterPropertiesSet();
|
||||
|
||||
// Wire up an invocation to be voted on
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
|
||||
// Setup a MockMethodInvocation, so voter can retrieve domainObject
|
||||
// (well actually it will access domainObject.getParent())
|
||||
MethodInvocation mi = getMethodInvocation(domainObject);
|
||||
|
||||
assertEquals(AccessDecisionVoter.ACCESS_GRANTED,
|
||||
voter.vote(new UsernamePasswordAuthenticationToken("rod", null), mi, attr));
|
||||
}
|
||||
|
||||
public void testVoterThrowsExceptionIfInvalidInternalMethodOfDomainObject()
|
||||
throws Exception {
|
||||
// Setup a domain object subject of this test
|
||||
SomeDomainObject domainObject = new SomeDomainObject("foo");
|
||||
|
||||
// Setup an AclManager
|
||||
AclManager aclManager = new MockAclManager(domainObject.getParent(), "rod",
|
||||
new AclEntry[]{
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
// Wire up a voter
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
voter.setAclManager(aclManager);
|
||||
voter.setProcessConfigAttribute("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
voter.setRequirePermission(new int[]{SimpleAclEntry.ADMINISTRATION, SimpleAclEntry.WRITE});
|
||||
voter.setProcessDomainObjectClass(SomeDomainObject.class);
|
||||
voter.setInternalMethod("getNonExistentParentName");
|
||||
voter.afterPropertiesSet();
|
||||
|
||||
// Wire up an invocation to be voted on
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
|
||||
// Setup a MockMethodInvocation, so voter can retrieve domainObject
|
||||
// (well actually it will access domainObject.getParent())
|
||||
MethodInvocation mi = getMethodInvocation(domainObject);
|
||||
|
||||
try {
|
||||
voter.vote(new UsernamePasswordAuthenticationToken("rod", null), mi, attr);
|
||||
fail("Should have thrown AuthorizationServiceException");
|
||||
} catch (AuthorizationServiceException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testVoterThrowsExceptionIfProcessDomainObjectNotFound()
|
||||
throws Exception {
|
||||
// Setup a domain object subject of this test
|
||||
SomeDomainObject domainObject = new SomeDomainObject("foo");
|
||||
|
||||
// Setup an AclManager
|
||||
AclManager aclManager = new MockAclManager(domainObject.getParent(), "rod",
|
||||
new AclEntry[]{
|
||||
new MockAclEntry(),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.ADMINISTRATION),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.READ),
|
||||
new SimpleAclEntry("rod", new MockAclObjectIdentity(), null, SimpleAclEntry.DELETE)
|
||||
});
|
||||
|
||||
// Wire up a voter
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
voter.setAclManager(aclManager);
|
||||
voter.setProcessConfigAttribute("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
voter.setRequirePermission(new int[]{SimpleAclEntry.ADMINISTRATION, SimpleAclEntry.WRITE});
|
||||
voter.setProcessDomainObjectClass(SomeDomainObject.class);
|
||||
voter.afterPropertiesSet();
|
||||
|
||||
// Wire up an invocation to be voted on
|
||||
List<ConfigAttribute> attr = SecurityConfig.createList("FOO_ADMIN_OR_WRITE_ACCESS");
|
||||
|
||||
// Setup a MockMethodInvocation that doesn't provide SomeDomainObject arg
|
||||
Class clazz = String.class;
|
||||
Method method = clazz.getMethod("toString", new Class[]{});
|
||||
|
||||
MethodInvocation mi = new SimpleMethodInvocation(new String(), method, new Object[]{domainObject});
|
||||
|
||||
try {
|
||||
voter.vote(new UsernamePasswordAuthenticationToken("rod", null), mi, attr);
|
||||
fail("Should have thrown AuthorizationServiceException");
|
||||
} catch (AuthorizationServiceException expected) {
|
||||
assertTrue(true);
|
||||
}
|
||||
}
|
||||
|
||||
public void testSetRequirePermissionFromString() {
|
||||
assertPermission("NOTHING", SimpleAclEntry.NOTHING);
|
||||
assertPermission("ADMINISTRATION", SimpleAclEntry.ADMINISTRATION);
|
||||
assertPermission("READ", SimpleAclEntry.READ);
|
||||
assertPermission("WRITE", SimpleAclEntry.WRITE);
|
||||
assertPermission("CREATE", SimpleAclEntry.CREATE);
|
||||
assertPermission("DELETE", SimpleAclEntry.DELETE);
|
||||
assertPermission(new String[] { "WRITE", "CREATE" }, new int[] { SimpleAclEntry.WRITE, SimpleAclEntry.CREATE });
|
||||
}
|
||||
|
||||
public void testSetRequirePermissionFromStringWrongValues() {
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
try {
|
||||
voter.setRequirePermissionFromString(new String[] { "X" });
|
||||
fail(IllegalArgumentException.class.getName() + " must have been thrown.");
|
||||
} catch (IllegalArgumentException e) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
|
||||
private void assertPermission(String text, int value) {
|
||||
assertPermission(new String[] { text }, new int[] { value });
|
||||
}
|
||||
|
||||
private void assertPermission(String[] text, int[] value) {
|
||||
BasicAclEntryVoter voter = new BasicAclEntryVoter();
|
||||
voter.setRequirePermissionFromString(text);
|
||||
assertEquals("Test incorreclty coded", value.length, text.length);
|
||||
assertEquals(value.length, voter.getRequirePermission().length);
|
||||
for (int i = 0; i < value.length; i++) {
|
||||
assertEquals(value[i], voter.getRequirePermission()[i]);
|
||||
}
|
||||
}
|
||||
|
||||
//~ Inner Classes ==================================================================================================
|
||||
|
||||
private class MockAclEntry implements AclEntry {
|
||||
// just so AclTag iterates some different types of AclEntrys
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user