SEC-1677: Create integrationTest task for Java projects and make all tests in itest module run as integration tests only.

2011-02-14 14:57:30 +00:00
parent a225dc3776
commit 44fb3aa4ab
33 changed files with 28 additions and 24 deletions
--- a/itest/context/src/integration-test/java/org/springframework/security/integration/HttpNamespaceWithMultipleInterceptorsTests.java
+++ b/itest/context/src/integration-test/java/org/springframework/security/integration/HttpNamespaceWithMultipleInterceptorsTests.java
@@ -0,0 +1,57 @@
+package org.springframework.security.integration;
+
+import static org.junit.Assert.*;
+
+import javax.servlet.http.HttpSession;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.mock.web.MockFilterChain;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpServletResponse;
+import org.springframework.mock.web.MockHttpSession;
+import org.springframework.security.authentication.TestingAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.web.FilterChainProxy;
+import org.springframework.security.web.context.HttpSessionSecurityContextRepository;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@ContextConfiguration(locations={"/http-extra-fsi-app-context.xml"})
+@RunWith(SpringJUnit4ClassRunner.class)
+public class HttpNamespaceWithMultipleInterceptorsTests {
+
+    @Autowired
+    private FilterChainProxy fcp;
+
+    @Test
+    public void requestThatIsMatchedByDefaultInterceptorIsAllowed() throws Exception {
+        MockHttpServletRequest request = new MockHttpServletRequest();
+        request.setServletPath("/somefile.html");
+        request.setSession(createAuthenticatedSession("ROLE_0", "ROLE_1", "ROLE_2"));
+        MockHttpServletResponse response = new MockHttpServletResponse();
+        fcp.doFilter(request, response, new MockFilterChain());
+        assertEquals(200, response.getStatus());
+    }
+
+    @Test
+    public void securedUrlAccessIsRejectedWithoutRequiredRole() throws Exception {
+        MockHttpServletRequest request = new MockHttpServletRequest();
+        request.setServletPath("/secure/somefile.html");
+        request.setSession(createAuthenticatedSession("ROLE_0"));
+        MockHttpServletResponse response = new MockHttpServletResponse();
+        fcp.doFilter(request, response, new MockFilterChain());
+        assertEquals(403, response.getStatus());
+    }
+
+    public HttpSession createAuthenticatedSession(String... roles) {
+        MockHttpSession session = new MockHttpSession();
+        SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("bob", "bobspassword", roles));
+        session.setAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY, SecurityContextHolder.getContext());
+        SecurityContextHolder.clearContext();
+        return session;
+    }
+
+
+}
--- a/itest/context/src/integration-test/java/org/springframework/security/integration/HttpPathParameterStrippingTests.java
+++ b/itest/context/src/integration-test/java/org/springframework/security/integration/HttpPathParameterStrippingTests.java
@@ -0,0 +1,65 @@
+package org.springframework.security.integration;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.mock.web.MockFilterChain;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpServletResponse;
+import org.springframework.mock.web.MockHttpSession;
+import org.springframework.security.authentication.TestingAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.web.FilterChainProxy;
+import org.springframework.security.web.context.HttpSessionSecurityContextRepository;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import javax.servlet.http.HttpSession;
+
+@ContextConfiguration(locations={"/http-path-param-stripping-app-context.xml"})
+@RunWith(SpringJUnit4ClassRunner.class)
+public class HttpPathParameterStrippingTests {
+
+    @Autowired
+    private FilterChainProxy fcp;
+
+    @Test
+    public void securedFilterChainCannotBeBypassedByAddingPathParameters() throws Exception {
+        MockHttpServletRequest request = new MockHttpServletRequest();
+        request.setPathInfo("/secured;x=y/admin.html");
+        request.setSession(createAuthenticatedSession("ROLE_USER"));
+        MockHttpServletResponse response = new MockHttpServletResponse();
+        fcp.doFilter(request, response, new MockFilterChain());
+        assertEquals(403, response.getStatus());
+    }
+
+    @Test
+    public void adminFilePatternCannotBeBypassedByAddingPathParameters() throws Exception {
+        MockHttpServletRequest request = new MockHttpServletRequest();
+        request.setServletPath("/secured/admin.html;x=user.html");
+        request.setSession(createAuthenticatedSession("ROLE_USER"));
+        MockHttpServletResponse response = new MockHttpServletResponse();
+        fcp.doFilter(request, response, new MockFilterChain());
+        assertEquals(403, response.getStatus());
+
+        // Try with pathInfo
+        request = new MockHttpServletRequest();
+        request.setServletPath("/secured");
+        request.setPathInfo("/admin.html;x=user.html");
+        request.setSession(createAuthenticatedSession("ROLE_USER"));
+        response = new MockHttpServletResponse();
+        fcp.doFilter(request, response, new MockFilterChain());
+        assertEquals(403, response.getStatus());
+    }
+
+    public HttpSession createAuthenticatedSession(String... roles) {
+        MockHttpSession session = new MockHttpSession();
+        SecurityContextHolder.getContext().setAuthentication(new TestingAuthenticationToken("bob", "bobspassword", roles));
+        session.setAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY, SecurityContextHolder.getContext());
+        SecurityContextHolder.clearContext();
+        return session;
+    }
+
+}
--- a/itest/context/src/integration-test/java/org/springframework/security/integration/MultiAnnotationTests.java
+++ b/itest/context/src/integration-test/java/org/springframework/security/integration/MultiAnnotationTests.java
@@ -0,0 +1,86 @@
+package org.springframework.security.integration;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.access.AccessDeniedException;
+import org.springframework.security.authentication.TestingAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.integration.multiannotation.MultiAnnotationService;
+import org.springframework.security.integration.multiannotation.PreAuthorizeService;
+import org.springframework.security.integration.multiannotation.SecuredService;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+/**
+ * @author Luke Taylor
+ */
+@ContextConfiguration(locations={"/multi-sec-annotation-app-context.xml"})
+@RunWith(SpringJUnit4ClassRunner.class)
+public class MultiAnnotationTests {
+    private final TestingAuthenticationToken joe_a = new TestingAuthenticationToken("joe","pass","ROLE_A");
+    private final TestingAuthenticationToken joe_b = new TestingAuthenticationToken("joe","pass","ROLE_B");
+
+    @Autowired
+    MultiAnnotationService service;
+    @Autowired
+    PreAuthorizeService preService;
+    @Autowired
+    SecuredService secService;
+
+    @After
+    @Before
+    public void clearContext() {
+        SecurityContextHolder.clearContext();
+    }
+
+    @Test(expected=AccessDeniedException.class)
+    public void preAuthorizeDeniedIsDenied() {
+        SecurityContextHolder.getContext().setAuthentication(joe_a);
+        service.preAuthorizeDenyAllMethod();
+    }
+
+    @Test(expected=AccessDeniedException.class)
+    public void preAuthorizeRoleAIsDeniedIfRoleMissing() {
+        SecurityContextHolder.getContext().setAuthentication(joe_b);
+        service.preAuthorizeHasRoleAMethod();
+    }
+
+    @Test
+    public void preAuthorizeRoleAIsAllowedIfRolePresent() {
+        SecurityContextHolder.getContext().setAuthentication(joe_a);
+        service.preAuthorizeHasRoleAMethod();
+    }
+
+    @Test
+    public void securedAnonymousIsAllowed() {
+        SecurityContextHolder.getContext().setAuthentication(joe_a);
+        service.securedAnonymousMethod();
+    }
+
+    @Test(expected=AccessDeniedException.class)
+    public void securedRoleAIsDeniedIfRoleMissing() {
+        SecurityContextHolder.getContext().setAuthentication(joe_b);
+        service.securedRoleAMethod();
+    }
+
+    @Test
+    public void securedRoleAIsAllowedIfRolePresent() {
+        SecurityContextHolder.getContext().setAuthentication(joe_a);
+        service.securedRoleAMethod();
+    }
+
+    @Test(expected=AccessDeniedException.class)
+    public void preAuthorizedOnlyServiceDeniesIfRoleMissing() throws Exception {
+        SecurityContextHolder.getContext().setAuthentication(joe_b);
+        preService.preAuthorizedMethod();
+    }
+
+    @Test(expected=AccessDeniedException.class)
+    public void securedOnlyRoleAServiceDeniesIfRoleMissing() throws Exception {
+        SecurityContextHolder.getContext().setAuthentication(joe_b);
+        secService.securedMethod();
+    }
+}
--- a/itest/context/src/integration-test/java/org/springframework/security/integration/SEC933ApplicationContextTests.java
+++ b/itest/context/src/integration-test/java/org/springframework/security/integration/SEC933ApplicationContextTests.java
@@ -0,0 +1,23 @@
+package org.springframework.security.integration;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@ContextConfiguration(locations={"/sec-933-app-context.xml"})
+@RunWith(SpringJUnit4ClassRunner.class)
+public class SEC933ApplicationContextTests {
+
+    @Autowired
+    private UserDetailsService userDetailsService;
+
+    @Test
+    public void testSimpleApplicationContextBootstrap() throws Exception {
+        assertNotNull(userDetailsService);
+    }
+}
--- a/itest/context/src/integration-test/java/org/springframework/security/integration/SEC936ApplicationContextTests.java
+++ b/itest/context/src/integration-test/java/org/springframework/security/integration/SEC936ApplicationContextTests.java
@@ -0,0 +1,30 @@
+package org.springframework.security.integration;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.access.AccessDeniedException;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.session.SessionRegistry;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+/**
+ * @author Luke Taylor
+ * @since 2.0
+ */
+@ContextConfiguration(locations={"/sec-936-app-context.xml"})
+@RunWith(SpringJUnit4ClassRunner.class)
+public class SEC936ApplicationContextTests {
+    @Autowired
+    /** SessionRegistry is used as the test service interface (nothing to do with the test) */
+    private SessionRegistry sessionRegistry;
+
+    @Test(expected=AccessDeniedException.class)
+    public void securityInterceptorHandlesCallWithNoTargetObject() {
+        SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken("bob","bobspassword"));
+        sessionRegistry.getAllPrincipals();
+    }
+
+}
--- a/itest/context/src/integration-test/java/org/springframework/security/integration/StubUserRepository.java
+++ b/itest/context/src/integration-test/java/org/springframework/security/integration/StubUserRepository.java
@@ -0,0 +1,7 @@
+package org.springframework.security.integration;
+
+public class StubUserRepository implements UserRepository {
+
+    public void doSomething() {
+    }
+}
--- a/itest/context/src/integration-test/java/org/springframework/security/integration/python/PythonInterpreterBasedSecurityTests.java
+++ b/itest/context/src/integration-test/java/org/springframework/security/integration/python/PythonInterpreterBasedSecurityTests.java
@@ -0,0 +1,26 @@
+package org.springframework.security.integration.python;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@ContextConfiguration(locations={"/python-method-access-app-context.xml"})
+@RunWith(SpringJUnit4ClassRunner.class)
+public class PythonInterpreterBasedSecurityTests {
+
+    @Autowired
+    private TestService service;
+
+    @Test
+    public void serviceMethod() throws Exception {
+        SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken("bob","bobspassword"));
+
+//        for (int i=0; i < 1000; i++) {
+            service.someMethod();
+//        }
+    }
+}
--- a/itest/context/src/integration-test/java/org/springframework/security/performance/FilterChainPerformanceTests.java
+++ b/itest/context/src/integration-test/java/org/springframework/security/performance/FilterChainPerformanceTests.java
@@ -0,0 +1,125 @@
+package org.springframework.security.performance;
+
+import org.junit.*;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.mock.web.MockFilterChain;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpServletResponse;
+import org.springframework.mock.web.MockHttpSession;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.web.FilterChainProxy;
+import org.springframework.security.web.context.HttpSessionSecurityContextRepository;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.util.StopWatch;
+
+import javax.servlet.http.HttpSession;
+import java.util.*;
+
+/**
+ *
+ * @author Luke Taylor
+ * @since 2.0
+ */
+@ContextConfiguration(locations={"/filter-chain-performance-app-context.xml"})
+@RunWith(SpringJUnit4ClassRunner.class)
+public class FilterChainPerformanceTests {
+    // Adjust as required
+    private static final int N_INVOCATIONS = 1; // 1000
+    private static final int N_AUTHORITIES = 2; // 200
+    private static StopWatch sw = new StopWatch("Filter Chain Performance Tests");
+
+    private final UsernamePasswordAuthenticationToken user = new UsernamePasswordAuthenticationToken("bob", "bobspassword", createRoles(N_AUTHORITIES));
+    private HttpSession session;
+
+    @Autowired
+    @Qualifier("fcpMinimalStack")
+    private FilterChainProxy minimalStack;
+
+    @Autowired
+    @Qualifier("fcpFullStack")
+    private FilterChainProxy fullStack;
+
+    @Before
+    public void createAuthenticatedSession() {
+        session = new MockHttpSession();
+        SecurityContextHolder.getContext().setAuthentication(user);
+        session.setAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY, SecurityContextHolder.getContext());
+        SecurityContextHolder.clearContext();
+    }
+
+    @After
+    public void clearContext() {
+        SecurityContextHolder.clearContext();
+    }
+
+    @AfterClass
+    public static void dumpStopWatch() {
+        System.out.println(sw.prettyPrint());
+    }
+
+    private MockHttpServletRequest createRequest(String url) {
+        MockHttpServletRequest request = new MockHttpServletRequest();
+        request.setSession(session);
+        request.setServletPath(url);
+        request.setMethod("GET");
+        return request;
+    }
+
+    private void runWithStack(FilterChainProxy stack) throws Exception {
+        for(int i = 0; i < N_INVOCATIONS; i++) {
+            MockHttpServletRequest request = createRequest("/somefile.html");
+            stack.doFilter(request, new MockHttpServletResponse(), new MockFilterChain());
+            session = request.getSession();
+        }
+    }
+
+    @Test
+    public void minimalStackInvocation() throws Exception {
+        sw.start("Run with Minimal Filter Stack");
+        runWithStack(minimalStack);
+        sw.stop();
+    }
+
+    @Test
+    public void fullStackInvocation() throws Exception {
+        sw.start("Run with Full Filter Stack");
+        runWithStack(fullStack);
+        sw.stop();
+    }
+
+    /**
+     * Creates data from 1 to N_AUTHORITIES in steps of 10, performing N_INVOCATIONS for each
+     */
+    @Test
+    public void provideDataOnScalingWithNumberOfAuthoritiesUserHas() throws Exception {
+        StopWatch sw = new StopWatch("Scaling with nAuthorities");
+        for (int user=0; user < N_AUTHORITIES/10; user ++) {
+            int nAuthorities = user == 0 ? 1 : user*10;
+            SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken("bob", "bobspassword", createRoles(nAuthorities)));
+            session.setAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY, SecurityContextHolder.getContext());
+            SecurityContextHolder.clearContext();
+            sw.start(Integer.toString(nAuthorities) + " authorities");
+            runWithStack(minimalStack);
+            System.out.println(sw.shortSummary());
+            sw.stop();
+        }
+        System.out.println(sw.prettyPrint());
+    }
+
+    private List<GrantedAuthority> createRoles(int howMany) {
+     // This is always the worst case scenario - the required role is ROLE_1, but they are created in reverse order
+        GrantedAuthority[] roles = new GrantedAuthority[howMany];
+
+        for (int i = howMany - 1; i >=0 ; i--) {
+            roles[i] = new SimpleGrantedAuthority("ROLE_" + i);
+        }
+
+        return Arrays.asList(roles);
+    }
+}
--- a/itest/context/src/integration-test/java/org/springframework/security/performance/ProtectPointcutPerformanceTests.java
+++ b/itest/context/src/integration-test/java/org/springframework/security/performance/ProtectPointcutPerformanceTests.java
@@ -0,0 +1,52 @@
+package org.springframework.security.performance;
+
+import static junit.framework.Assert.fail;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.BeansException;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.security.authentication.AuthenticationCredentialsNotFoundException;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.session.SessionRegistry;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.util.StopWatch;
+
+/**
+ * @author Luke Taylor
+ */
+@ContextConfiguration(locations={"/protect-pointcut-performance-app-context.xml"})
+@RunWith(SpringJUnit4ClassRunner.class)
+public class ProtectPointcutPerformanceTests implements ApplicationContextAware {
+    ApplicationContext ctx;
+
+    @Before
+    public void clearContext() {
+        SecurityContextHolder.clearContext();
+    }
+
+    // Method for use with profiler
+    @Test
+    public void usingPrototypeDoesNotParsePointcutOnEachCall() {
+        StopWatch sw = new StopWatch();
+        sw.start();
+        for (int i = 0; i < 1000; i++) {
+            try {
+                SessionRegistry reg = (SessionRegistry) ctx.getBean("sessionRegistryPrototype");
+                reg.getAllPrincipals();
+                fail("Expected AuthenticationCredentialsNotFoundException");
+            } catch (AuthenticationCredentialsNotFoundException expected) {
+            }
+        }
+        sw.stop();
+//        assertTrue(sw.getTotalTimeMillis() < 1000);
+
+    }
+
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+        ctx = applicationContext;
+    }
+}
--- a/itest/context/src/integration-test/resources/filter-chain-performance-app-context.xml
+++ b/itest/context/src/integration-test/resources/filter-chain-performance-app-context.xml
@@ -0,0 +1,104 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+  -
+  -->
+
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:sec="http://www.springframework.org/schema/security"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+                        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security.xsd">
+
+    <bean id="fcpMinimalStack" class="org.springframework.security.web.FilterChainProxy">
+        <sec:filter-chain-map path-type="ant">
+            <sec:filter-chain pattern="/**" filters="scpf,preAuthFilter,etf,fsi"/>
+        </sec:filter-chain-map>
+    </bean>
+
+    <bean id="fcpFullStack" class="org.springframework.security.web.FilterChainProxy">
+        <sec:filter-chain-map path-type="ant">
+            <sec:filter-chain pattern="/**" filters="scpf,preAuthFilter,apf,basicPf,logoutFilter,scharf,etf,fsi"/>
+        </sec:filter-chain-map>
+    </bean>
+
+    <bean id="authenticationManager" class="org.springframework.security.authentication.ProviderManager">
+        <property name="providers">
+            <list>
+               <bean class="org.springframework.security.authentication.dao.DaoAuthenticationProvider">
+                   <property name="userDetailsService" ref="userService"/>
+               </bean>
+            </list>
+        </property>
+    </bean>
+
+    <sec:user-service id="userService">
+        <sec:user name="bob" password="bobspassword" authorities="ROLE_0,ROLE_1"/>
+    </sec:user-service>
+
+    <bean id="scpf" class="org.springframework.security.web.context.SecurityContextPersistenceFilter"/>
+
+    <bean id="apf" class="org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter">
+        <property name="authenticationManager" ref="authenticationManager"/>
+    </bean>
+
+    <bean id="basicPf" class="org.springframework.security.web.authentication.www.BasicAuthenticationFilter">
+        <property name="authenticationManager" ref="authenticationManager"/>
+        <property name="ignoreFailure" value="true"/>
+    </bean>
+
+    <bean id="preAuthFilter" class="org.springframework.security.web.authentication.preauth.RequestHeaderAuthenticationFilter">
+        <property name="authenticationManager" ref="authenticationManager"/>
+        <property name="exceptionIfHeaderMissing" value="false" />
+    </bean>
+
+    <bean id="scharf" class="org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter" />
+
+    <bean id="preAuthenticatedProcessingFilterEntryPoint"
+            class="org.springframework.security.web.authentication.Http403ForbiddenEntryPoint"/>
+
+    <bean id="logoutFilter" class="org.springframework.security.web.authentication.logout.LogoutFilter">
+        <constructor-arg value="/"/>
+        <constructor-arg>
+            <list>
+                <bean class="org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler"/>
+            </list>
+        </constructor-arg>
+    </bean>
+
+    <bean id="etf" class="org.springframework.security.web.access.ExceptionTranslationFilter">
+        <property name="authenticationEntryPoint" ref="preAuthenticatedProcessingFilterEntryPoint"/>
+    </bean>
+
+    <bean id="preAuthenticatedAuthenticationProvider" class="org.springframework.security.web.authentication.preauth.PreAuthenticatedAuthenticationProvider">
+        <property name="preAuthenticatedUserDetailsService" ref="preAuthenticatedUserDetailsService"/>
+    </bean>
+
+    <bean id="preAuthenticatedUserDetailsService" class="org.springframework.security.core.userdetails.UserDetailsByNameServiceWrapper">
+        <property name="userDetailsService" ref="userService"/>
+    </bean>
+
+    <bean id="accessDecisionManager" class="org.springframework.security.access.vote.AffirmativeBased">
+        <property name="allowIfAllAbstainDecisions" value="false"/>
+        <property name="decisionVoters">
+            <list>
+                <ref bean="roleVoter"/>
+            </list>
+        </property>
+    </bean>
+
+    <bean id="fsi" class="org.springframework.security.web.access.intercept.FilterSecurityInterceptor">
+        <property name="authenticationManager" ref="authenticationManager"/>
+        <property name="accessDecisionManager" ref="accessDecisionManager"/>
+        <property name="securityMetadataSource">
+            <sec:filter-security-metadata-source>
+                <sec:intercept-url pattern="/secure/extreme/**" access="ROLE_2"/>
+                <sec:intercept-url pattern="/secure/**" access="ROLE_1"/>
+                <sec:intercept-url pattern="/**" access="ROLE_0"/>
+            </sec:filter-security-metadata-source>
+        </property>
+    </bean>
+
+    <bean id="roleVoter" class="org.springframework.security.access.vote.RoleVoter"/>
+
+</beans>
--- a/itest/context/src/integration-test/resources/http-extra-fsi-app-context.xml
+++ b/itest/context/src/integration-test/resources/http-extra-fsi-app-context.xml
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+  -
+  -->
+
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:sec="http://www.springframework.org/schema/security"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+                        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security.xsd">
+
+    <sec:http use-expressions="true">
+        <!-- Slip in a bean property name EL test -->
+        <sec:intercept-url pattern="/**" access="fsi.getAccessDecisionManager() eq accessDecisionManager" />
+        <sec:form-login />
+        <sec:custom-filter ref="fsi" after="FILTER_SECURITY_INTERCEPTOR " />
+    </sec:http>
+
+    <bean id="fsi" class="org.springframework.security.web.access.intercept.FilterSecurityInterceptor">
+        <property name="authenticationManager" ref="authenticationManager"/>
+        <property name="accessDecisionManager" ref="accessDecisionManager"/>
+        <property name="securityMetadataSource">
+            <sec:filter-security-metadata-source>
+                <sec:intercept-url pattern="/secure/extreme/**" access="ROLE_2"/>
+                <sec:intercept-url pattern="/secure/**" access="ROLE_1"/>
+            </sec:filter-security-metadata-source>
+        </property>
+        <property name="observeOncePerRequest" value="false" />
+    </bean>
+
+    <bean id="accessDecisionManager" class="org.springframework.security.access.vote.AffirmativeBased">
+        <property name="allowIfAllAbstainDecisions" value="false"/>
+        <property name="decisionVoters">
+            <list>
+                <bean class="org.springframework.security.access.vote.RoleVoter"/>
+            </list>
+        </property>
+    </bean>
+
+    <sec:authentication-manager alias="authenticationManager">
+        <sec:authentication-provider>
+            <sec:user-service id="userService">
+                <sec:user name="notused" password="notused" authorities="ROLE_0,ROLE_1"/>
+            </sec:user-service>
+        </sec:authentication-provider>
+    </sec:authentication-manager>
+
+</beans>
--- a/itest/context/src/integration-test/resources/http-path-param-stripping-app-context.xml
+++ b/itest/context/src/integration-test/resources/http-path-param-stripping-app-context.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+  -
+  -->
+
+<b:beans xmlns="http://www.springframework.org/schema/security"
+    xmlns:b="http://www.springframework.org/schema/beans"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+                        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd">
+
+    <http pattern="/secured/**">
+        <intercept-url pattern="/secured/*user.html" access="ROLE_USER" />
+        <intercept-url pattern="/secured/admin.html" access="ROLE_ADMIN" />
+        <intercept-url pattern="/secured/user/**" access="ROLE_USER" />
+        <intercept-url pattern="/secured/admin/*" access="ROLE_ADMIN" />
+        <intercept-url pattern="/**" access="ROLE_NO_ACCESS" />
+        <form-login />
+    </http>
+
+    <http pattern="/**" security="none" />
+
+    <authentication-manager alias="authenticationManager">
+        <authentication-provider>
+            <user-service id="userService">
+                <user name="notused" password="notused" authorities="ROLE_0,ROLE_1"/>
+            </user-service>
+        </authentication-provider>
+    </authentication-manager>
+
+</b:beans>
--- a/itest/context/src/integration-test/resources/logback-test.xml
+++ b/itest/context/src/integration-test/resources/logback-test.xml
@@ -0,0 +1,15 @@
+<configuration>
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <logger name="org.springframework.security" level="${sec.log.level}:-WARN"/>
+  <logger name="org.apache.directory" level="ERROR"/>
+
+  <root level="${root.level}:-WARN">
+    <appender-ref ref="STDOUT" />
+  </root>
+
+</configuration>
--- a/itest/context/src/integration-test/resources/multi-sec-annotation-app-context.xml
+++ b/itest/context/src/integration-test/resources/multi-sec-annotation-app-context.xml
@@ -0,0 +1,26 @@
+<b:beans xmlns="http://www.springframework.org/schema/security"
+    xmlns:b="http://www.springframework.org/schema/beans"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:aop="http://www.springframework.org/schema/aop"
+    xmlns:tx="http://www.springframework.org/schema/tx"
+    xmlns:security="http://www.springframework.org/schema/security"
+    xsi:schemaLocation="
+        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
+        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security.xsd">
+
+    <global-method-security pre-post-annotations="enabled" secured-annotations="enabled" />
+
+    <b:bean class="org.springframework.security.integration.multiannotation.MultiAnnotationServiceImpl"/>
+    <b:bean class="org.springframework.security.integration.multiannotation.PreAuthorizeServiceImpl"/>
+    <b:bean class="org.springframework.security.integration.multiannotation.SecuredServiceImpl"/>
+
+    <authentication-manager>
+        <authentication-provider>
+            <user-service>
+                <user name="bob" password="bobspassword" authorities="ROLE_A,ROLE_B"/>
+            </user-service>
+        </authentication-provider>
+    </authentication-manager>
+
+</b:beans>
--- a/itest/context/src/integration-test/resources/protect-pointcut-performance-app-context.xml
+++ b/itest/context/src/integration-test/resources/protect-pointcut-performance-app-context.xml
@@ -0,0 +1,26 @@
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:sec="http://www.springframework.org/schema/security"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+                        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd">
+
+    <sec:global-method-security>
+        <sec:protect-pointcut expression="execution(* org.springframework.security.core.session.SessionRegistry.refreshLastRequest(..))" access="ROLE_ADMIN" />
+        <sec:protect-pointcut expression="execution(* org.springframework.security.core.session.SessionRegistry.registerNewSession(..))" access="ROLE_ADMIN" />
+        <sec:protect-pointcut expression="execution(* org.springframework.security.core.session.SessionRegistry.removeSessionInformation(..))" access="ROLE_ADMIN" />
+        <sec:protect-pointcut expression="execution(* org.springframework.security.core.session.SessionRegistry.get*(..))" access="ROLE_ADMIN" />
+    </sec:global-method-security>
+
+    <bean id="sessionRegistry" class="org.springframework.security.core.session.SessionRegistryImpl" />
+
+    <bean id="sessionRegistryPrototype" class="org.springframework.security.core.session.SessionRegistryImpl" scope="prototype"/>
+
+    <sec:authentication-manager alias="authenticationManager">
+        <sec:authentication-provider>
+            <sec:user-service id="userService">
+                <sec:user name="notused" password="notused" authorities="ROLE_0,ROLE_1"/>
+            </sec:user-service>
+        </sec:authentication-provider>
+    </sec:authentication-manager>
+
+</beans>
--- a/itest/context/src/integration-test/resources/python-method-access-app-context.xml
+++ b/itest/context/src/integration-test/resources/python-method-access-app-context.xml
@@ -0,0 +1,34 @@
+<b:beans xmlns="http://www.springframework.org/schema/security"
+    xmlns:b="http://www.springframework.org/schema/beans"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:aop="http://www.springframework.org/schema/aop"
+    xmlns:tx="http://www.springframework.org/schema/tx"
+    xmlns:security="http://www.springframework.org/schema/security"
+    xsi:schemaLocation="
+        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
+        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security.xsd">
+
+    <global-method-security pre-post-annotations="enabled">
+        <pre-post-annotation-handling>
+            <invocation-attribute-factory ref="attributeFactory"/>
+            <pre-invocation-advice ref="preAdvice"/>
+            <post-invocation-advice ref="postAdvice"/>
+        </pre-post-annotation-handling>
+    </global-method-security>
+
+    <b:bean id="attributeFactory" class="org.springframework.security.integration.python.PythonInterpreterPrePostInvocationAttributeFactory"/>
+    <b:bean id="preAdvice" class="org.springframework.security.integration.python.PythonInterpreterPreInvocationAdvice"/>
+    <b:bean id="postAdvice" class="org.springframework.security.integration.python.PythonInterpreterPostInvocationAdvice"/>
+
+    <b:bean id="service" class="org.springframework.security.integration.python.TestServiceImpl"/>
+
+    <authentication-manager>
+        <authentication-provider>
+            <user-service>
+                <user name="bob" password="bobspassword" authorities="ROLE_A,ROLE_B"/>
+            </user-service>
+        </authentication-provider>
+    </authentication-manager>
+
+</b:beans>
--- a/itest/context/src/integration-test/resources/sec-933-app-context.xml
+++ b/itest/context/src/integration-test/resources/sec-933-app-context.xml
@@ -0,0 +1,32 @@
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:aop="http://www.springframework.org/schema/aop"
+    xmlns:tx="http://www.springframework.org/schema/tx"
+    xmlns:security="http://www.springframework.org/schema/security"
+    xsi:schemaLocation="
+    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
+    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
+    http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security.xsd">
+
+
+    <bean id="userRepository" class="org.springframework.security.integration.StubUserRepository"/>
+
+    <security:authentication-manager>
+        <security:authentication-provider
+        user-service-ref="userDetailsService" />
+    </security:authentication-manager>
+
+    <bean id="userDetailsService" class="org.springframework.security.integration.UserDetailsServiceImpl">
+        <property name="userRepository" ref="userRepository"/>
+    </bean>
+
+    <security:global-method-security>
+        <security:protect-pointcut
+            expression="execution(* org.springframework.security.integration.*Repository+.*(..))"
+            access="ROLE_LOGGEDIN" />
+    </security:global-method-security>
+
+    <aop:aspectj-autoproxy/>
+
+</beans>
--- a/itest/context/src/integration-test/resources/sec-936-app-context.xml
+++ b/itest/context/src/integration-test/resources/sec-936-app-context.xml
@@ -0,0 +1,54 @@
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:util="http://www.springframework.org/schema/util"
+    xmlns:security="http://www.springframework.org/schema/security"
+    xsi:schemaLocation="
+    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
+    http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd">
+
+    <security:authentication-manager alias="authenticationManager">
+        <security:authentication-provider>
+            <security:user-service>
+                <security:user name="bob" password="bobspassword" authorities="ROLE_A,ROLE_B"/>
+            </security:user-service>
+        </security:authentication-provider>
+    </security:authentication-manager>
+
+    <bean id="accessDecisionManager" class="org.springframework.security.access.vote.AffirmativeBased">
+        <property name="allowIfAllAbstainDecisions" value="false"/>
+        <property name="decisionVoters">
+            <util:list>
+                <bean class="org.springframework.security.access.vote.RoleVoter" />
+                <bean class="org.springframework.security.access.vote.AuthenticatedVoter" />
+            </util:list>
+        </property>
+    </bean>
+
+    <bean id="securityInterceptor" class="org.springframework.security.access.intercept.aopalliance.MethodSecurityInterceptor">
+        <property name="validateConfigAttributes" value="true"/>
+        <property name="rejectPublicInvocations" value="true"/>
+        <property name="authenticationManager" ref="authenticationManager"/>
+        <property name="accessDecisionManager" ref="accessDecisionManager"/>
+        <property name="securityMetadataSource">
+            <security:method-security-metadata-source>
+                <security:protect method="org.springframework.security.core.session.SessionRegistry.get*" access="ROLE_C" />
+            </security:method-security-metadata-source>
+        </property>
+    </bean>
+
+    <bean id="httpRemoteService" class="org.springframework.aop.framework.ProxyFactoryBean">
+        <property name="proxyInterfaces" value="org.springframework.security.core.session.SessionRegistry"/>
+        <property name="interceptorNames">
+            <list>
+                <value>securityInterceptor</value>
+                <value>httpInvokerClientInterceptor</value>
+            </list>
+        </property>
+    </bean>
+
+    <bean id="httpInvokerClientInterceptor" class="org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor">
+        <property name="serviceUrl" value="http://somehost/someUrl"/>
+    </bean>
+
+</beans>
--- a/itest/context/src/integration-test/resources/someMethod.py
+++ b/itest/context/src/integration-test/resources/someMethod.py
@@ -0,0 +1,8 @@
+print authentication.name;
+
+for authority in authentication.authorities:
+    print authority
+
+print "Granting access"
+
+allow = 1