Added ChannelSecurityInterceptor as a replacement for SecurityEnforcingChannelInterceptor. It is a subclass of AbstractSecurityInterceptor. Also added the ChannelInvocationDefinitionSource, ChannelInvocation (the secured object), and ChannelAccessPolicy.

org.springframework.integration.security/src/test/java/org/springframework/integration/security/channel/ChannelAdapterSecurityIntegrationTests-context.xml

@@ -1,26 +1,30 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <beans:beans xmlns="http://www.springframework.org/schema/integration"
- 	xmlns:si-security="http://www.springframework.org/schema/integration-security"
+ 	xmlns:si-security="http://www.springframework.org/schema/integration/security"
 	xmlns:beans="http://www.springframework.org/schema/beans"
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xmlns:security="http://www.springframework.org/schema/security"
 	xmlns:context="http://www.springframework.org/schema/context"
-	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
-              http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.xsd
-              http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration-1.0.xsd
-              http://www.springframework.org/schema/integration-security http://www.springframework.org/schema/integration/spring-integration-security-1.0.xsd
-              http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
+	xsi:schemaLocation="http://www.springframework.org/schema/beans
+			http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+			http://www.springframework.org/schema/security
+			http://www.springframework.org/schema/security/spring-security-2.0.xsd
+			http://www.springframework.org/schema/integration
+			http://www.springframework.org/schema/integration/spring-integration-1.0.xsd
+			http://www.springframework.org/schema/integration/security
+			http://www.springframework.org/schema/integration/spring-integration-security-1.0.xsd
+			http://www.springframework.org/schema/context
+			http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 
 	<beans:import resource="classpath:org/springframework/integration/security/config/commonSecurityConfiguration.xml"/>
 
 	<message-bus/>
 
-	<si-security:secured-channels send-access="ROLE_ADMIN">
-		<si-security:channel-name-pattern>secured.*</si-security:channel-name-pattern>
+	<si-security:secured-channels>
+		<si-security:access-policy pattern="secured.*" send-access="ROLE_ADMIN"/>
 	</si-security:secured-channels>
 
-	<beans:bean id="testTarget"
-		class="org.springframework.integration.security.endpoint.TestTarget"/>
+	<beans:bean id="testTarget" class="org.springframework.integration.security.endpoint.TestTarget"/>
 
 	<channel-adapter id="securedChannelAdapter" target="testTarget"/>
 

org.springframework.integration.security/src/test/java/org/springframework/integration/security/channel/ChannelSecurityInterceptorBeanPostProcessorTests.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2002-2008 the original author or authors.
+ *
+ * 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.integration.security.channel;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.regex.Pattern;
+
+import org.junit.Test;
+
+import org.springframework.aop.support.AopUtils;
+import org.springframework.integration.channel.MessageChannel;
+import org.springframework.integration.channel.QueueChannel;
+import org.springframework.integration.security.config.ChannelSecurityInterceptorBeanPostProcessor;
+
+/**
+ * @author Mark Fisher
+ */
+public class ChannelSecurityInterceptorBeanPostProcessorTests {
+
+	@Test
+	public void securedChannelIsProxied() {
+		ChannelInvocationDefinitionSource objectDefinitionSource = new ChannelInvocationDefinitionSource();
+		objectDefinitionSource.addPatternMapping(Pattern.compile("secured.*"), new ChannelAccessPolicy("ROLE_ADMIN", null));
+		ChannelSecurityInterceptor interceptor = new ChannelSecurityInterceptor(objectDefinitionSource);
+		ChannelSecurityInterceptorBeanPostProcessor postProcessor = new ChannelSecurityInterceptorBeanPostProcessor(interceptor);
+		QueueChannel securedChannel = new QueueChannel();
+		securedChannel.setBeanName("securedChannel");
+		MessageChannel postProcessedChannel = (MessageChannel) postProcessor.postProcessAfterInitialization(securedChannel, "securedChannel");
+		assertTrue(AopUtils.isAopProxy(postProcessedChannel));
+	}
+
+	@Test
+	public void nonsecuredChannelIsNotProxied() {
+		ChannelInvocationDefinitionSource objectDefinitionSource = new ChannelInvocationDefinitionSource();
+		objectDefinitionSource.addPatternMapping(Pattern.compile("secured.*"), new ChannelAccessPolicy("ROLE_ADMIN", null));
+		ChannelSecurityInterceptor interceptor = new ChannelSecurityInterceptor(objectDefinitionSource);
+		ChannelSecurityInterceptorBeanPostProcessor postProcessor = new ChannelSecurityInterceptorBeanPostProcessor(interceptor);
+		QueueChannel channel = new QueueChannel();
+		channel.setBeanName("testChannel");
+		MessageChannel postProcessedChannel = (MessageChannel) postProcessor.postProcessAfterInitialization(channel, "testChannel");
+		assertFalse(AopUtils.isAopProxy(postProcessedChannel));
+	}
+
+}

org.springframework.integration.security/src/test/java/org/springframework/integration/security/channel/ChannelSecurityInterceptorTests.java

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2002-2008 the original author or authors.
+ *
+ * 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.integration.security.channel;
+
+import java.util.Collections;
+import java.util.regex.Pattern;
+
+import org.junit.After;
+import org.junit.Test;
+
+import org.springframework.aop.framework.ProxyFactory;
+import org.springframework.integration.channel.MessageChannel;
+import org.springframework.integration.channel.QueueChannel;
+import org.springframework.integration.message.StringMessage;
+import org.springframework.integration.security.SecurityTestUtil;
+import org.springframework.security.AccessDeniedException;
+import org.springframework.security.AuthenticationException;
+import org.springframework.security.MockAuthenticationManager;
+import org.springframework.security.context.SecurityContext;
+import org.springframework.security.context.SecurityContextHolder;
+import org.springframework.security.vote.AffirmativeBased;
+import org.springframework.security.vote.RoleVoter;
+
+/**
+ * @author Mark Fisher
+ */
+public class ChannelSecurityInterceptorTests {
+
+	@After
+	public void clearSecurityContext() {
+		SecurityContextHolder.clearContext();
+	}
+
+	@Test(expected = AuthenticationException.class)
+	public void securedSendWithoutAuthentication() throws Exception {
+		MessageChannel channel = getSecuredChannel("ROLE_ADMIN");
+		channel.send(new StringMessage("test"));
+	}
+
+	@Test(expected = AccessDeniedException.class)
+	public void securedSendWithoutRole() throws Exception {
+		MessageChannel channel = getSecuredChannel("ROLE_ADMIN");
+		SecurityContext context = SecurityTestUtil.createContext("test", "pwd", "ROLE_USER");
+		SecurityContextHolder.setContext(context);
+		channel.send(new StringMessage("test"));
+	}
+
+	@Test
+	public void securedSendWithRole() throws Exception {
+		MessageChannel channel = getSecuredChannel("ROLE_ADMIN");
+		SecurityContext context = SecurityTestUtil.createContext("test", "pwd", "ROLE_ADMIN");
+		SecurityContextHolder.setContext(context);
+		channel.send(new StringMessage("test"));
+	}
+
+
+	private static MessageChannel getSecuredChannel(String role) throws Exception {
+		QueueChannel channel = new QueueChannel();
+		channel.setBeanName("securedChannel");
+		ProxyFactory proxyFactory = new ProxyFactory(channel);
+		proxyFactory.addAdvice(createInterceptor(role));
+		return (MessageChannel) proxyFactory.getProxy();
+	}
+
+	private static ChannelSecurityInterceptor createInterceptor(String role) throws Exception {
+		ChannelInvocationDefinitionSource objectDefinitionSource = new ChannelInvocationDefinitionSource();
+		objectDefinitionSource.addPatternMapping(Pattern.compile("secured.*"), new ChannelAccessPolicy(role, null));
+		ChannelSecurityInterceptor interceptor = new ChannelSecurityInterceptor(objectDefinitionSource);
+		AffirmativeBased accessDecisionManager = new AffirmativeBased();
+		accessDecisionManager.setDecisionVoters(Collections.singletonList(new RoleVoter()));
+		accessDecisionManager.afterPropertiesSet();
+		interceptor.setAccessDecisionManager(accessDecisionManager);
+		interceptor.setAuthenticationManager(new MockAuthenticationManager(true));
+		interceptor.afterPropertiesSet();
+		return interceptor;
+	}
+
+}

org.springframework.integration.security/src/test/java/org/springframework/integration/security/channel/SecurityEnforcingChannelInterceptorTests.java

@@ -1,160 +0,0 @@
-/*
- * Copyright 2002-2008 the original author or authors.
- *
- * 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.integration.security.channel;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import org.springframework.integration.channel.QueueChannel;
-import org.springframework.integration.message.StringMessage;
-import org.springframework.integration.security.channel.SecurityEnforcingChannelInterceptor;
-import org.springframework.security.AccessDecisionManager;
-import org.springframework.security.AccessDeniedException;
-import org.springframework.security.Authentication;
-import org.springframework.security.ConfigAttribute;
-import org.springframework.security.ConfigAttributeDefinition;
-import org.springframework.security.GrantedAuthorityImpl;
-import org.springframework.security.InsufficientAuthenticationException;
-import org.springframework.security.context.SecurityContextHolder;
-import org.springframework.security.providers.TestingAuthenticationToken;
-
-/**
- * @author Jonas Partner
- */
-public class SecurityEnforcingChannelInterceptorTests {
-
-	private QueueChannel channel;
-
-	private SecurityEnforcingChannelInterceptor securityChannelInterceptor;
-
-
-	@Before
-	public void setUp() {
-		channel = new QueueChannel();
-		SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken(
-				"stub", "passwd", new GrantedAuthorityImpl[] {}));
-	}
-
-	@After
-	public void clearSecurityContext(){
-		SecurityContextHolder.clearContext();
-	}
-
-	@Test(expected = AccessDeniedException.class)
-	public void testSendSecuredAndAccessDenied() {
-		try {
-			Runnable decision = new Runnable() {
-				public void run() {
-					throw new AccessDeniedException("nope");
-				}
-			};
-			this.registerInterceptor(new ConfigurableAccessDecisionManager(decision));
-			this.securityChannelInterceptor.setSendSecurityAttributes(new ConfigAttributeDefinition("ROLE_ADMIN"));
-			this.channel.send(new StringMessage("test"));
-		}
-		finally {
-			assertEquals("Wrong message count after refused send.", 0, channel.clear().size());
-		}
-	}
-
-	@Test
-	public void testUnsecuredSend() {
-		this.registerInterceptor(new ConfigurableAccessDecisionManager(null));
-		this.channel.send(new StringMessage("test"));
-		assertEquals("Wrong message count after send.", 1,channel.clear().size());
-	}
-
-	@Test
-	public void testSendSecuredAndAllowed() {
-		Runnable decision = new Runnable() {
-			public void run() {
-			}
-		};
-		this.registerInterceptor(new ConfigurableAccessDecisionManager(decision));
-		this.securityChannelInterceptor.setSendSecurityAttributes(new ConfigAttributeDefinition("ROLE_ADMIN"));
-		this.channel.send(new StringMessage("test"));
-		assertEquals("Wrong message count after send", 1, channel.clear().size());
-	}
-
-	@Test
-	public void testReceiveSecuredAndAllowed() {
-		Runnable decision = new Runnable() {
-			public void run() {
-			}
-		};
-		this.registerInterceptor(new ConfigurableAccessDecisionManager(decision));
-		this.securityChannelInterceptor.setReceiveSecurityAttributes(new ConfigAttributeDefinition("ROLE_ADMIN"));
-		this.channel.receive(0);
-	}
-
-	@Test(expected = AccessDeniedException.class)
-	public void testReceiveSecuredAndAccessDenied() {
-		Runnable decision = new Runnable() {
-			public void run() {
-				throw new AccessDeniedException("nope");
-			}
-		};
-		this.registerInterceptor(new ConfigurableAccessDecisionManager(decision));
-		this.securityChannelInterceptor.setReceiveSecurityAttributes(new ConfigAttributeDefinition("ROLE_ADMIN"));
-		this.channel.receive(0);
-	}
-
-	@Test
-	public void testReceiveUnsecured() {
-		Runnable decision = new Runnable() {
-			public void run() {
-				throw new AccessDeniedException("nope");
-			}
-		};
-		this.registerInterceptor(new ConfigurableAccessDecisionManager(decision));
-		this.channel.receive(0);
-	}
-
-
-	private void registerInterceptor(AccessDecisionManager accessDecisionManager) {
-		securityChannelInterceptor = new SecurityEnforcingChannelInterceptor(accessDecisionManager); 
-		channel.addInterceptor(securityChannelInterceptor);
-	}
-
-
-	private static class ConfigurableAccessDecisionManager implements AccessDecisionManager {
-
-		private Runnable decisionRunner;
-
-		public ConfigurableAccessDecisionManager(Runnable decision) {
-			this.decisionRunner = decision;
-		}
-
-		public void decide(Authentication authentication, Object object, ConfigAttributeDefinition config)
-				throws AccessDeniedException, InsufficientAuthenticationException {
-			this.decisionRunner.run();
-		}
-
-		public boolean supports(ConfigAttribute attribute) {
-			return true;
-		}
-
-		@SuppressWarnings("unchecked")
-		public boolean supports(Class clazz) {
-			return true;
-		}
-	}
-
-}

org.springframework.integration.security/src/test/java/org/springframework/integration/security/config/SecuredChannelsParserTests-context.xml

@@ -1,36 +1,29 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <beans:beans xmlns="http://www.springframework.org/schema/integration"
- 	xmlns:si-security="http://www.springframework.org/schema/integration-security"
+ 	xmlns:si-security="http://www.springframework.org/schema/integration/security"
 	xmlns:beans="http://www.springframework.org/schema/beans"
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xmlns:security="http://www.springframework.org/schema/security"
 	xmlns:context="http://www.springframework.org/schema/context"
-	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
-              http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.xsd
-              http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration-1.0.xsd
-              http://www.springframework.org/schema/integration-security http://www.springframework.org/schema/integration/spring-integration-security-1.0.xsd
-              http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
+	xsi:schemaLocation="http://www.springframework.org/schema/beans
+			http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+			http://www.springframework.org/schema/security
+			http://www.springframework.org/schema/security/spring-security-2.0.xsd
+			http://www.springframework.org/schema/integration
+			http://www.springframework.org/schema/integration/spring-integration-1.0.xsd
+			http://www.springframework.org/schema/integration/security
+			http://www.springframework.org/schema/integration/spring-integration-security-1.0.xsd
+			http://www.springframework.org/schema/context
+			http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 
 	<beans:import resource="classpath:org/springframework/integration/security/config/commonSecurityConfiguration.xml"/>
 
-	<si-security:secured-channels send-access="ROLE_ADMIN">
-		<si-security:channel-name-pattern>adminRequiredForSend</si-security:channel-name-pattern>
+	<si-security:secured-channels>
+		<si-security:access-policy pattern="adminRequiredForSend" send-access="ROLE_ADMIN"/>
+		<si-security:access-policy pattern="adminOrUserRequiredForSend" send-access="ROLE_ADMIN, ROLE_USER"/>
+		<si-security:access-policy pattern="adminRequiredForReceive" receive-access="ROLE_ADMIN"/>
+		<si-security:access-policy pattern="adminOrUserRequiredForReceive" receive-access="ROLE_ADMIN, ROLE_USER"/>
+		<si-security:access-policy pattern="adminRequiredForSendAndReceive" send-access="ROLE_ADMIN" receive-access="ROLE_ADMIN"/>
 	</si-security:secured-channels>
 
-	<si-security:secured-channels send-access="ROLE_ADMIN, ROLE_USER">
-		<si-security:channel-name-pattern>adminOrUserRequiredForSend</si-security:channel-name-pattern>
-	</si-security:secured-channels>
-
-	<si-security:secured-channels receive-access="ROLE_ADMIN">
-		<si-security:channel-name-pattern>adminRequiredForReceive</si-security:channel-name-pattern>
-	</si-security:secured-channels>
-
-	<si-security:secured-channels receive-access="ROLE_ADMIN, ROLE_USER">
-		<si-security:channel-name-pattern>adminOrUserRequiredForReceive</si-security:channel-name-pattern>
-	</si-security:secured-channels>
-
-	<si-security:secured-channels receive-access="ROLE_ADMIN" send-access="ROLE_ADMIN">
-		<si-security:channel-name-pattern>adminForSendAndReceive</si-security:channel-name-pattern>
-	</si-security:secured-channels>
-
-</beans:beans>
+</beans:beans>

org.springframework.integration.security/src/test/java/org/springframework/integration/security/config/SecuredChannelsParserTests.java

@@ -16,25 +16,42 @@
 
 package org.springframework.integration.security.config;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
 
 import org.junit.Before;
 import org.junit.Test;
 
+import org.springframework.aop.Advisor;
+import org.springframework.aop.framework.Advised;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.beans.DirectFieldAccessor;
 import org.springframework.integration.channel.AbstractPollableChannel;
 import org.springframework.integration.channel.ChannelInterceptor;
+import org.springframework.integration.channel.MessageChannel;
 import org.springframework.integration.message.Message;
 import org.springframework.integration.message.selector.MessageSelector;
-import org.springframework.integration.security.channel.SecurityEnforcingChannelInterceptor;
-import org.springframework.security.SecurityConfig;
+import org.springframework.integration.security.channel.ChannelAccessPolicy;
+import org.springframework.integration.security.channel.ChannelInvocationDefinitionSource;
+import org.springframework.integration.security.channel.ChannelSecurityInterceptor;
+import org.springframework.security.ConfigAttribute;
+import org.springframework.security.ConfigAttributeDefinition;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
 
 /**
  * @author Jonas Partner
+ * @author Mark Fisher
  */
 @ContextConfiguration
 public class SecuredChannelsParserTests extends AbstractJUnit4SpringContextTests {
@@ -48,67 +65,125 @@ public class SecuredChannelsParserTests extends AbstractJUnit4SpringContextTests
 
 	@Test
 	public void testAdminRequiredForSend() {
-		applicationContext.getAutowireCapableBeanFactory().applyBeanPostProcessorsAfterInitialization(messageChannel,
-				"adminRequiredForSend");
-		assertEquals("Wrong count of interceptors ", 1, messageChannel.interceptors.size());
-		SecurityEnforcingChannelInterceptor interceptor = (SecurityEnforcingChannelInterceptor) messageChannel.interceptors
-				.get(0);
-		assertTrue("ROLE_ADMIN not found as send attribute", interceptor.getSendSecurityAttributes().contains(
-				new SecurityConfig("ROLE_ADMIN")));
-		assertNull("Receive security attribute were not null", interceptor.getReceiveSecurityAttributes());
+		String beanName = "adminRequiredForSend";
+		messageChannel.setBeanName(beanName);
+		MessageChannel proxy = (MessageChannel) applicationContext.getAutowireCapableBeanFactory()
+				.applyBeanPostProcessorsAfterInitialization(messageChannel, beanName);
+		assertTrue("Channel was not proxied", AopUtils.isAopProxy(proxy));
+		Advisor[] advisors = ((Advised) proxy).getAdvisors();
+		assertEquals("Wrong number of interceptors", 1, advisors.length);
+		ChannelSecurityInterceptor interceptor = (ChannelSecurityInterceptor) advisors[0].getAdvice();
+		ChannelAccessPolicy policy = this.retrievePolicyForPatternString(beanName, interceptor);
+		assertNotNull("Pattern '" + beanName + "' is not included in mappings", policy);
+		ConfigAttributeDefinition sendDefinition = policy.getConfigAttributeDefinitionForSend();
+		ConfigAttributeDefinition receiveDefinition = policy.getConfigAttributeDefinitionForReceive();
+		assertTrue("ROLE_ADMIN not found as send attribute", this.getRolesFromDefintion(sendDefinition).contains("ROLE_ADMIN"));
+		assertNull("Policy applies to receive", receiveDefinition);
 	}
 
 	@Test
 	public void testAdminOrUserRequiredForSend() {
-		applicationContext.getAutowireCapableBeanFactory().applyBeanPostProcessorsAfterInitialization(messageChannel,
-				"adminOrUserRequiredForSend");
-		assertEquals("Wrong count of interceptors ", 1, messageChannel.interceptors.size());
-		SecurityEnforcingChannelInterceptor interceptor = (SecurityEnforcingChannelInterceptor) messageChannel.interceptors
-				.get(0);
-		assertTrue("ROLE_ADMIN not found as send attribute", interceptor.getSendSecurityAttributes().contains(
-				new SecurityConfig("ROLE_ADMIN")));
-		assertTrue("ROLE_USER not found as send attribute", interceptor.getSendSecurityAttributes().contains(
-				new SecurityConfig("ROLE_USER")));
-		assertNull("Receive security attribute were not null", interceptor.getReceiveSecurityAttributes());
+		String beanName = "adminOrUserRequiredForSend";
+		messageChannel.setBeanName(beanName);
+		MessageChannel proxy = (MessageChannel) applicationContext.getAutowireCapableBeanFactory()
+				.applyBeanPostProcessorsAfterInitialization(messageChannel, beanName);
+		assertTrue("Channel was not proxied", AopUtils.isAopProxy(proxy));
+		Advisor[] advisors = ((Advised) proxy).getAdvisors();
+		assertEquals("Wrong number of interceptors", 1, advisors.length);
+		ChannelSecurityInterceptor interceptor = (ChannelSecurityInterceptor) advisors[0].getAdvice();
+		ChannelAccessPolicy policy = this.retrievePolicyForPatternString(beanName, interceptor);
+		assertNotNull("Pattern '" + beanName + "' is not included in mappings", policy);
+		ConfigAttributeDefinition sendDefinition = policy.getConfigAttributeDefinitionForSend();
+		ConfigAttributeDefinition receiveDefinition = policy.getConfigAttributeDefinitionForReceive();
+		Collection<String> sendRoles = this.getRolesFromDefintion(sendDefinition);
+		assertTrue("ROLE_ADMIN not found as send attribute", sendRoles.contains("ROLE_ADMIN"));
+		assertTrue("ROLE_USER not found as send attribute", sendRoles.contains("ROLE_USER"));
+		assertNull("Policy applies to receive", receiveDefinition);
 	}
 
 	@Test
 	public void testAdminRequiredForReceive() {
-		applicationContext.getAutowireCapableBeanFactory().applyBeanPostProcessorsAfterInitialization(messageChannel,
-				"adminRequiredForReceive");
-		assertEquals("Wrong count of interceptors ", 1, messageChannel.interceptors.size());
-		SecurityEnforcingChannelInterceptor interceptor = (SecurityEnforcingChannelInterceptor) messageChannel.interceptors
-				.get(0);
-		assertTrue("ROLE_ADMIN not found as receive attribute", interceptor.getReceiveSecurityAttributes().contains(
-				new SecurityConfig("ROLE_ADMIN")));
-		assertNull("Send security attribute were not null", interceptor.getSendSecurityAttributes());
+		String beanName = "adminRequiredForReceive";
+		messageChannel.setBeanName(beanName);
+		MessageChannel proxy = (MessageChannel) applicationContext.getAutowireCapableBeanFactory()
+				.applyBeanPostProcessorsAfterInitialization(messageChannel, beanName);
+		assertTrue("Channel was not proxied", AopUtils.isAopProxy(proxy));
+		Advisor[] advisors = ((Advised) proxy).getAdvisors();
+		assertEquals("Wrong number of interceptors", 1, advisors.length);
+		ChannelSecurityInterceptor interceptor = (ChannelSecurityInterceptor) advisors[0].getAdvice();
+		ChannelAccessPolicy policy = this.retrievePolicyForPatternString(beanName, interceptor);
+		assertNotNull("Pattern '" + beanName + "' is not included in mappings", policy);
+		ConfigAttributeDefinition sendDefinition = policy.getConfigAttributeDefinitionForSend();
+		ConfigAttributeDefinition receiveDefinition = policy.getConfigAttributeDefinitionForReceive();
+		Collection<String> receiveRoles = this.getRolesFromDefintion(receiveDefinition);
+		assertTrue("ROLE_ADMIN not found as receive attribute", receiveRoles.contains("ROLE_ADMIN"));
+		assertNull("Policy applies to send", sendDefinition);
 	}
 
 	@Test
 	public void testAdminOrUserRequiredForReceive() {
-		applicationContext.getAutowireCapableBeanFactory().applyBeanPostProcessorsAfterInitialization(messageChannel,
-				"adminOrUserRequiredForReceive");
-		assertEquals("Wrong count of interceptors ", 1, messageChannel.interceptors.size());
-		SecurityEnforcingChannelInterceptor interceptor = (SecurityEnforcingChannelInterceptor) messageChannel.interceptors
-				.get(0);
-		assertTrue("ROLE_ADMIN not found as receive attribute", interceptor.getReceiveSecurityAttributes().contains(
-				new SecurityConfig("ROLE_ADMIN")));
-		assertTrue("ROLE_USER not found as receive attribute", interceptor.getReceiveSecurityAttributes().contains(
-				new SecurityConfig("ROLE_USER")));
-		assertNull("Send security attribute were not null", interceptor.getSendSecurityAttributes());
+		String beanName = "adminOrUserRequiredForReceive";
+		messageChannel.setBeanName(beanName);
+		MessageChannel proxy = (MessageChannel) applicationContext.getAutowireCapableBeanFactory()
+				.applyBeanPostProcessorsAfterInitialization(messageChannel, beanName);
+		assertTrue("Channel was not proxied", AopUtils.isAopProxy(proxy));
+		Advisor[] advisors = ((Advised) proxy).getAdvisors();
+		assertEquals("Wrong number of interceptors", 1, advisors.length);
+		ChannelSecurityInterceptor interceptor = (ChannelSecurityInterceptor) advisors[0].getAdvice();
+		ChannelAccessPolicy policy = this.retrievePolicyForPatternString(beanName, interceptor);
+		assertNotNull("Pattern '" + beanName + "' is not included in mappings", policy);
+		ConfigAttributeDefinition sendDefinition = policy.getConfigAttributeDefinitionForSend();
+		ConfigAttributeDefinition receiveDefinition = policy.getConfigAttributeDefinitionForReceive();
+		Collection<String> receiveRoles = this.getRolesFromDefintion(receiveDefinition);
+		assertTrue("ROLE_ADMIN not found as receive attribute", receiveRoles.contains("ROLE_ADMIN"));
+		assertTrue("ROLE_USER not found as receive attribute", receiveRoles.contains("ROLE_USER"));
+		assertNull("Policy applies to send", sendDefinition);
 	}
 
 	@Test
 	public void testAdminRequiredForSendAndReceive() {
-		applicationContext.getAutowireCapableBeanFactory().applyBeanPostProcessorsAfterInitialization(messageChannel,
-				"adminForSendAndReceive");
-		assertEquals("Wrong count of interceptors ", 1, messageChannel.interceptors.size());
-		SecurityEnforcingChannelInterceptor interceptor = (SecurityEnforcingChannelInterceptor) messageChannel.interceptors
-				.get(0);
-		assertTrue("ROLE_ADMIN not found as receive attribute", interceptor.getReceiveSecurityAttributes().contains(
-				new SecurityConfig("ROLE_ADMIN")));
-		assertTrue("ROLE_USER not found as send attribute", interceptor.getSendSecurityAttributes().contains(
-				new SecurityConfig("ROLE_ADMIN")));
+		String beanName = "adminRequiredForSendAndReceive";
+		messageChannel.setBeanName(beanName);
+		MessageChannel proxy = (MessageChannel) applicationContext.getAutowireCapableBeanFactory()
+				.applyBeanPostProcessorsAfterInitialization(messageChannel, beanName);
+		assertTrue("Channel was not proxied", AopUtils.isAopProxy(proxy));
+		Advisor[] advisors = ((Advised) proxy).getAdvisors();
+		assertEquals("Wrong number of interceptors", 1, advisors.length);
+		ChannelSecurityInterceptor interceptor = (ChannelSecurityInterceptor) advisors[0].getAdvice();
+		ChannelAccessPolicy policy = this.retrievePolicyForPatternString(beanName, interceptor);
+		assertNotNull("Pattern '" + beanName + "' is not included in mappings", policy);
+		ConfigAttributeDefinition sendDefinition = policy.getConfigAttributeDefinitionForSend();
+		ConfigAttributeDefinition receiveDefinition = policy.getConfigAttributeDefinitionForReceive();
+		assertNotNull("Pattern does not apply to 'send'", sendDefinition);
+		assertNotNull("Pattern does not apply to 'receive'", receiveDefinition);
+		Collection<String> sendRoles = this.getRolesFromDefintion(sendDefinition);
+		Collection<String> receiveRoles = this.getRolesFromDefintion(receiveDefinition);
+		assertTrue("ROLE_ADMIN not found in send attributes", sendRoles.contains("ROLE_ADMIN"));
+		assertTrue("ROLE_ADMIN not found in receive attributes", receiveRoles.contains("ROLE_ADMIN"));
+	}
+
+
+	@SuppressWarnings("unchecked")
+	private ChannelAccessPolicy retrievePolicyForPatternString(String patternString, ChannelSecurityInterceptor interceptor) {
+		DirectFieldAccessor accessor = new DirectFieldAccessor((ChannelInvocationDefinitionSource) interceptor.obtainObjectDefinitionSource());
+		Map<Pattern, ChannelAccessPolicy> policies = (Map<Pattern, ChannelAccessPolicy>) accessor.getPropertyValue("patternMappings");
+		for (Map.Entry<Pattern, ChannelAccessPolicy> entry : policies.entrySet()) {
+			if (entry.getKey().pattern().equals(patternString)) {
+				return entry.getValue();
+			}
+		}
+		return null;
+	}
+
+	@SuppressWarnings("unchecked")
+	private Collection<String> getRolesFromDefintion(ConfigAttributeDefinition definition) {
+		Set<String> roles = new HashSet<String>();
+		Collection configAttributes = definition.getConfigAttributes();
+		for (Object next : configAttributes) {
+			ConfigAttribute attribute = (ConfigAttribute) next;
+			roles.add(attribute.getAttribute());
+		}
+		return roles;
 	}
 
 

org.springframework.integration.security/src/test/java/org/springframework/integration/security/config/SecurityPropagatingChannelsParserTests-noPropagationByDefaultContext.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <beans:beans xmlns="http://www.springframework.org/schema/integration"
-	xmlns:si-security="http://www.springframework.org/schema/integration-security"
+	xmlns:si-security="http://www.springframework.org/schema/integration/security"
 	xmlns:beans="http://www.springframework.org/schema/beans"
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xmlns:security="http://www.springframework.org/schema/security"
@@ -8,7 +8,7 @@
 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
               http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.xsd
               http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration-1.0.xsd
-              http://www.springframework.org/schema/integration-security http://www.springframework.org/schema/integration/spring-integration-security-1.0.xsd
+              http://www.springframework.org/schema/integration/security http://www.springframework.org/schema/integration/spring-integration-security-1.0.xsd
               http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 
 	<si-security:security-propagating-channels

org.springframework.integration.security/src/test/java/org/springframework/integration/security/config/SecurityPropagatingChannelsParserTests-propagateByDefaultContext.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <beans:beans xmlns="http://www.springframework.org/schema/integration"
- 	xmlns:si-security="http://www.springframework.org/schema/integration-security"
+ 	xmlns:si-security="http://www.springframework.org/schema/integration/security"
 	xmlns:beans="http://www.springframework.org/schema/beans"
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xmlns:security="http://www.springframework.org/schema/security"
@@ -8,7 +8,7 @@
 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
               http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.xsd
               http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration-1.0.xsd
-              http://www.springframework.org/schema/integration-security http://www.springframework.org/schema/integration/spring-integration-security-1.0.xsd
+              http://www.springframework.org/schema/integration/security http://www.springframework.org/schema/integration/spring-integration-security-1.0.xsd
               http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 
 	<si-security:security-propagating-channels propagate-by-default="true"/>

org.springframework.integration.security/src/test/java/org/springframework/integration/security/config/commonSecurityConfiguration.xml

@@ -11,6 +11,8 @@
 
 	<context:annotation-config/>	
 
+	<beans:bean id="authenticationManager" class="org.springframework.security.MockAuthenticationManager"/>
+
 	<beans:bean id="accessDecisionManager" class="org.springframework.security.vote.AffirmativeBased">
 		<beans:property name="allowIfAllAbstainDecisions" value="true"/>
 		<beans:property name="decisionVoters">

org.springframework.integration.security/src/test/java/org/springframework/integration/security/endpoint/EndpointSecurityIntegrationTests-context.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <beans:beans xmlns="http://www.springframework.org/schema/integration"
-	xmlns:si-security="http://www.springframework.org/schema/integration-security"
+	xmlns:si-security="http://www.springframework.org/schema/integration/security"
 	xmlns:beans="http://www.springframework.org/schema/beans"
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xmlns:security="http://www.springframework.org/schema/security"
@@ -8,7 +8,7 @@
 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
               http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.xsd
               http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration-1.0.xsd
-              http://www.springframework.org/schema/integration-security http://www.springframework.org/schema/integration/spring-integration-security-1.0.xsd
+              http://www.springframework.org/schema/integration/security http://www.springframework.org/schema/integration/spring-integration-security-1.0.xsd
               http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 
 	<message-bus/>