SEC-576: Committed pre-autheticated contribution. Still has to be more thoroughly reviewed.

2026-08-05 01:36:56 +00:00 · 2008-01-22 13:55:19 +00:00
parent 35a7928cb9
commit c8b9f24038
32 changed files with 2116 additions and 0 deletions
@@ -0,0 +1,102 @@
+package org.springframework.security.providers.preauth;
+
+import org.springframework.security.providers.UsernamePasswordAuthenticationToken;
+import org.springframework.security.userdetails.User;
+import org.springframework.security.userdetails.UserDetails;
+import org.springframework.security.userdetails.UsernameNotFoundException;
+import org.springframework.security.Authentication;
+import org.springframework.security.GrantedAuthority;
+
+import junit.framework.TestCase;
+
+/**
+ * 
+ * @author TSARDD
+ * @since 18-okt-2007
+ */
+public class PreAuthenticatedAuthenticationProviderTests extends TestCase {
+	private static final String SUPPORTED_USERNAME = "dummyUser";
+
+	public final void testAfterPropertiesSet() {
+		PreAuthenticatedAuthenticationProvider provider = new PreAuthenticatedAuthenticationProvider();
+		try {
+			provider.afterPropertiesSet();
+			fail("AfterPropertiesSet didn't throw expected exception");
+		} catch (IllegalArgumentException expected) {
+		} catch (Exception unexpected) {
+			fail("AfterPropertiesSet throws unexpected exception");
+		}
+	}
+
+	public final void testAuthenticateInvalidToken() throws Exception {
+		UserDetails ud = new User("dummyUser", "dummyPwd", true, true, true, true, new GrantedAuthority[] {});
+		PreAuthenticatedAuthenticationProvider provider = getProvider(ud);
+		Authentication request = new UsernamePasswordAuthenticationToken("dummyUser", "dummyPwd");
+		Authentication result = provider.authenticate(request);
+		assertNull(result);
+	}
+
+	public final void testAuthenticateKnownUser() throws Exception {
+		UserDetails ud = new User("dummyUser", "dummyPwd", true, true, true, true, new GrantedAuthority[] {});
+		PreAuthenticatedAuthenticationProvider provider = getProvider(ud);
+		Authentication request = new PreAuthenticatedAuthenticationToken("dummyUser", "dummyPwd");
+		Authentication result = provider.authenticate(request);
+		assertNotNull(result);
+		assertEquals(result.getPrincipal(), ud);
+		// @TODO: Add more asserts?
+	}
+
+	public final void testAuthenticateIgnoreCredentials() throws Exception {
+		UserDetails ud = new User("dummyUser1", "dummyPwd1", true, true, true, true, new GrantedAuthority[] {});
+		PreAuthenticatedAuthenticationProvider provider = getProvider(ud);
+		Authentication request = new PreAuthenticatedAuthenticationToken("dummyUser1", "dummyPwd2");
+		Authentication result = provider.authenticate(request);
+		assertNotNull(result);
+		assertEquals(result.getPrincipal(), ud);
+		// @TODO: Add more asserts?
+	}
+
+	public final void testAuthenticateUnknownUser() throws Exception {
+		UserDetails ud = new User("dummyUser1", "dummyPwd", true, true, true, true, new GrantedAuthority[] {});
+		PreAuthenticatedAuthenticationProvider provider = getProvider(ud);
+		Authentication request = new PreAuthenticatedAuthenticationToken("dummyUser2", "dummyPwd");
+		Authentication result = provider.authenticate(request);
+		assertNull(result);
+	}
+
+	public final void testSupportsArbitraryObject() throws Exception {
+		PreAuthenticatedAuthenticationProvider provider = getProvider(null);
+		assertFalse(provider.supports(Authentication.class));
+	}
+
+	public final void testSupportsPreAuthenticatedAuthenticationToken() throws Exception {
+		PreAuthenticatedAuthenticationProvider provider = getProvider(null);
+		assertTrue(provider.supports(PreAuthenticatedAuthenticationToken.class));
+	}
+
+	public void testGetSetOrder() throws Exception {
+		PreAuthenticatedAuthenticationProvider provider = getProvider(null);
+		provider.setOrder(333);
+		assertEquals(provider.getOrder(), 333);
+	}
+
+	private PreAuthenticatedAuthenticationProvider getProvider(UserDetails aUserDetails) throws Exception {
+		PreAuthenticatedAuthenticationProvider result = new PreAuthenticatedAuthenticationProvider();
+		result.setPreAuthenticatedUserDetailsService(getPreAuthenticatedUserDetailsService(aUserDetails));
+		result.afterPropertiesSet();
+		return result;
+	}
+
+	private PreAuthenticatedUserDetailsService getPreAuthenticatedUserDetailsService(final UserDetails aUserDetails) {
+		return new PreAuthenticatedUserDetailsService() {
+			public UserDetails getUserDetails(PreAuthenticatedAuthenticationToken token) throws UsernameNotFoundException {
+				if (aUserDetails != null && aUserDetails.getUsername().equals(token.getName())) {
+					return aUserDetails;
+				} else {
+					return null;
+				}
+			}
+		};
+	}
+
+}
@@ -0,0 +1,57 @@
+package org.springframework.security.providers.preauth;
+
+import org.springframework.security.GrantedAuthorityImpl;
+import org.springframework.security.GrantedAuthority;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import junit.framework.TestCase;
+
+/**
+ * 
+ * @author TSARDD
+ * @since 18-okt-2007
+ */
+public class PreAuthenticatedAuthenticationTokenTests extends TestCase {
+
+	public void testPreAuthenticatedAuthenticationTokenRequestWithDetails() {
+		Object principal = "dummyUser";
+		Object credentials = "dummyCredentials";
+		Object details = "dummyDetails";
+		PreAuthenticatedAuthenticationToken token = new PreAuthenticatedAuthenticationToken(principal, credentials);
+		token.setDetails(details);
+		assertEquals(principal, token.getPrincipal());
+		assertEquals(credentials, token.getCredentials());
+		assertEquals(details, token.getDetails());
+		assertNull(token.getAuthorities());
+	}
+
+	public void testPreAuthenticatedAuthenticationTokenRequestWithoutDetails() {
+		Object principal = "dummyUser";
+		Object credentials = "dummyCredentials";
+		PreAuthenticatedAuthenticationToken token = new PreAuthenticatedAuthenticationToken(principal, credentials);
+		assertEquals(principal, token.getPrincipal());
+		assertEquals(credentials, token.getCredentials());
+		assertNull(token.getDetails());
+		assertNull(token.getAuthorities());
+	}
+
+	public void testPreAuthenticatedAuthenticationTokenResponse() {
+		Object principal = "dummyUser";
+		Object credentials = "dummyCredentials";
+		GrantedAuthority[] gas = new GrantedAuthority[] { new GrantedAuthorityImpl("Role1") };
+		PreAuthenticatedAuthenticationToken token = new PreAuthenticatedAuthenticationToken(principal, credentials, gas);
+		assertEquals(principal, token.getPrincipal());
+		assertEquals(credentials, token.getCredentials());
+		assertNull(token.getDetails());
+		assertNotNull(token.getAuthorities());
+		Collection expectedColl = Arrays.asList(gas);
+		Collection resultColl = Arrays.asList(token.getAuthorities());
+		assertTrue("GrantedAuthority collections do not match; result: " + resultColl + ", expected: " + expectedColl, expectedColl
+				.containsAll(resultColl)
+				&& resultColl.containsAll(expectedColl));
+
+	}
+
+}
@@ -0,0 +1,79 @@
+package org.springframework.security.providers.preauth;
+
+import org.springframework.security.GrantedAuthorityImpl;
+import org.springframework.security.GrantedAuthority;
+import org.springframework.security.userdetails.UserDetails;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import junit.framework.TestCase;
+
+/**
+ * 
+ * @author TSARDD
+ * @since 18-okt-2007
+ */
+public class PreAuthenticatedGrantedAuthoritiesUserDetailsServiceTests extends TestCase {
+
+	public final void testGetUserDetailsInvalidType() {
+		PreAuthenticatedGrantedAuthoritiesUserDetailsService svc = new PreAuthenticatedGrantedAuthoritiesUserDetailsService();
+		PreAuthenticatedAuthenticationToken token = new PreAuthenticatedAuthenticationToken("dummy", "dummy");
+		token.setDetails(new Object());
+		try {
+			svc.getUserDetails(token);
+			fail("Expected exception didn't occur");
+		} catch (IllegalArgumentException expected) {
+		}
+	}
+
+	public final void testGetUserDetailsNoDetails() {
+		PreAuthenticatedGrantedAuthoritiesUserDetailsService svc = new PreAuthenticatedGrantedAuthoritiesUserDetailsService();
+		PreAuthenticatedAuthenticationToken token = new PreAuthenticatedAuthenticationToken("dummy", "dummy");
+		token.setDetails(null);
+		try {
+			svc.getUserDetails(token);
+			fail("Expected exception didn't occur");
+		} catch (IllegalArgumentException expected) {
+		}
+	}
+
+	public final void testGetUserDetailsEmptyAuthorities() {
+		final String userName = "dummyUser";
+		final GrantedAuthority[] gas = new GrantedAuthority[] {};
+		testGetUserDetails(userName, gas);
+	}
+
+	public final void testGetUserDetailsWithAuthorities() {
+		final String userName = "dummyUser";
+		final GrantedAuthority[] gas = new GrantedAuthority[] { new GrantedAuthorityImpl("Role1"), new GrantedAuthorityImpl("Role2") };
+		testGetUserDetails(userName, gas);
+	}
+
+	private void testGetUserDetails(final String userName, final GrantedAuthority[] gas) {
+		PreAuthenticatedGrantedAuthoritiesUserDetailsService svc = new PreAuthenticatedGrantedAuthoritiesUserDetailsService();
+		PreAuthenticatedAuthenticationToken token = new PreAuthenticatedAuthenticationToken(userName, "dummy");
+		token.setDetails(new PreAuthenticatedGrantedAuthoritiesRetriever() {
+			public GrantedAuthority[] getPreAuthenticatedGrantedAuthorities() {
+				return gas;
+			}
+		});
+		UserDetails ud = svc.getUserDetails(token);
+		assertTrue(ud.isAccountNonExpired());
+		assertTrue(ud.isAccountNonLocked());
+		assertTrue(ud.isCredentialsNonExpired());
+		assertTrue(ud.isEnabled());
+		assertEquals(ud.getUsername(), userName);
+
+		//Password is not saved by
+		// PreAuthenticatedGrantedAuthoritiesUserDetailsService
+		//assertEquals(ud.getPassword(),password);
+
+		Collection expectedColl = Arrays.asList(gas);
+		Collection resultColl = Arrays.asList(ud.getAuthorities());
+		assertTrue("GrantedAuthority collections do not match; result: " + resultColl + ", expected: " + expectedColl, expectedColl
+				.containsAll(resultColl)
+				&& resultColl.containsAll(expectedColl));
+	}
+
+}
@@ -0,0 +1,51 @@
+package org.springframework.security.providers.preauth;
+
+import org.springframework.security.userdetails.UserDetails;
+import org.springframework.security.userdetails.UsernameNotFoundException;
+import org.springframework.security.userdetails.UserDetailsService;
+import org.springframework.security.userdetails.User;
+import org.springframework.security.GrantedAuthorityImpl;
+import org.springframework.security.GrantedAuthority;
+
+import junit.framework.TestCase;
+
+import org.springframework.dao.DataAccessException;
+
+/**
+ * 
+ * @author TSARDD
+ * @since 18-okt-2007
+ */
+public class UserDetailsByNameServiceWrapperTests extends TestCase {
+
+	public final void testAfterPropertiesSet() {
+		UserDetailsByNameServiceWrapper svc = new UserDetailsByNameServiceWrapper();
+		try {
+			svc.afterPropertiesSet();
+			fail("AfterPropertiesSet didn't throw expected exception");
+		} catch (IllegalArgumentException expected) {
+		} catch (Exception unexpected) {
+			fail("AfterPropertiesSet throws unexpected exception");
+		}
+	}
+
+	public final void testGetUserDetails() throws Exception {
+		UserDetailsByNameServiceWrapper svc = new UserDetailsByNameServiceWrapper();
+		final User user = new User("dummy", "dummy", true, true, true, true, new GrantedAuthority[] { new GrantedAuthorityImpl("dummy") });
+		svc.setUserDetailsService(new UserDetailsService() {
+			public UserDetails loadUserByUsername(String name) throws UsernameNotFoundException, DataAccessException {
+				if (user != null && user.getUsername().equals(name)) {
+					return user;
+				} else {
+					return null;
+				}
+			}
+		});
+		svc.afterPropertiesSet();
+		UserDetails result1 = svc.getUserDetails(new PreAuthenticatedAuthenticationToken("dummy", "dummy"));
+		assertEquals("Result doesn't match original user", user, result1);
+		UserDetails result2 = svc.getUserDetails(new PreAuthenticatedAuthenticationToken("dummy2", "dummy"));
+		assertNull("Result should have been null", result2);
+	}
+
+}
@@ -0,0 +1,26 @@
+package org.springframework.security.rolemapping;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import junit.framework.TestCase;
+
+/**
+ * 
+ * @author TSARDD
+ * @since 18-okt-2007
+ */
+public class SimpleMappableRolesRetrieverTests extends TestCase {
+
+	public final void testGetSetMappableRoles() {
+		String[] roles = new String[] { "Role1", "Role2" };
+		SimpleMappableRolesRetriever r = new SimpleMappableRolesRetriever();
+		r.setMappableRoles(roles);
+		String[] result = r.getMappableRoles();
+		Collection resultColl = Arrays.asList(result);
+		Collection rolesColl = Arrays.asList(roles);
+		assertTrue("Role collections do not match; result: " + resultColl + ", expected: " + rolesColl, rolesColl.containsAll(resultColl)
+				&& resultColl.containsAll(rolesColl));
+	}
+
+}
@@ -0,0 +1,121 @@
+package org.springframework.security.rolemapping;
+
+import org.springframework.security.GrantedAuthority;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+
+import junit.framework.TestCase;
+
+/**
+ * 
+ * @author TSARDD
+ * @since 18-okt-2007
+ */
+public class SimpleRoles2GrantedAuthoritiesMapperTests extends TestCase {
+
+	public final void testAfterPropertiesSetConvertToUpperAndLowerCase() {
+		SimpleRoles2GrantedAuthoritiesMapper mapper = new SimpleRoles2GrantedAuthoritiesMapper();
+		mapper.setConvertRoleToLowerCase(true);
+		mapper.setConvertRoleToUpperCase(true);
+		try {
+			mapper.afterPropertiesSet();
+			fail("Expected exception not thrown");
+		} catch (IllegalArgumentException expected) {
+		} catch (Exception unexpected) {
+			fail("Unexpected exception: " + unexpected);
+		}
+	}
+
+	public final void testAfterPropertiesSet() {
+		SimpleRoles2GrantedAuthoritiesMapper mapper = new SimpleRoles2GrantedAuthoritiesMapper();
+		try {
+			mapper.afterPropertiesSet();
+		} catch (Exception unexpected) {
+			fail("Unexpected exception: " + unexpected);
+		}
+	}
+
+	public final void testGetGrantedAuthoritiesNoConversion() {
+		String[] roles = { "Role1", "Role2" };
+		String[] expectedGas = { "Role1", "Role2" };
+		SimpleRoles2GrantedAuthoritiesMapper mapper = getDefaultMapper();
+		testGetGrantedAuthorities(mapper, roles, expectedGas);
+	}
+
+	public final void testGetGrantedAuthoritiesToUpperCase() {
+		String[] roles = { "Role1", "Role2" };
+		String[] expectedGas = { "ROLE1", "ROLE2" };
+		SimpleRoles2GrantedAuthoritiesMapper mapper = getDefaultMapper();
+		mapper.setConvertRoleToUpperCase(true);
+		testGetGrantedAuthorities(mapper, roles, expectedGas);
+	}
+
+	public final void testGetGrantedAuthoritiesToLowerCase() {
+		String[] roles = { "Role1", "Role2" };
+		String[] expectedGas = { "role1", "role2" };
+		SimpleRoles2GrantedAuthoritiesMapper mapper = getDefaultMapper();
+		mapper.setConvertRoleToLowerCase(true);
+		testGetGrantedAuthorities(mapper, roles, expectedGas);
+	}
+
+	public final void testGetGrantedAuthoritiesAddPrefixIfAlreadyExisting() {
+		String[] roles = { "Role1", "Role2", "ROLE_Role3" };
+		String[] expectedGas = { "ROLE_Role1", "ROLE_Role2", "ROLE_ROLE_Role3" };
+		SimpleRoles2GrantedAuthoritiesMapper mapper = getDefaultMapper();
+		mapper.setAddPrefixIfAlreadyExisting(true);
+		mapper.setRolePrefix("ROLE_");
+		testGetGrantedAuthorities(mapper, roles, expectedGas);
+	}
+
+	public final void testGetGrantedAuthoritiesDontAddPrefixIfAlreadyExisting1() {
+		String[] roles = { "Role1", "Role2", "ROLE_Role3" };
+		String[] expectedGas = { "ROLE_Role1", "ROLE_Role2", "ROLE_Role3" };
+		SimpleRoles2GrantedAuthoritiesMapper mapper = getDefaultMapper();
+		mapper.setAddPrefixIfAlreadyExisting(false);
+		mapper.setRolePrefix("ROLE_");
+		testGetGrantedAuthorities(mapper, roles, expectedGas);
+	}
+
+	public final void testGetGrantedAuthoritiesDontAddPrefixIfAlreadyExisting2() {
+		String[] roles = { "Role1", "Role2", "role_Role3" };
+		String[] expectedGas = { "ROLE_Role1", "ROLE_Role2", "ROLE_role_Role3" };
+		SimpleRoles2GrantedAuthoritiesMapper mapper = getDefaultMapper();
+		mapper.setAddPrefixIfAlreadyExisting(false);
+		mapper.setRolePrefix("ROLE_");
+		testGetGrantedAuthorities(mapper, roles, expectedGas);
+	}
+
+	public final void testGetGrantedAuthoritiesCombination1() {
+		String[] roles = { "Role1", "Role2", "role_Role3" };
+		String[] expectedGas = { "ROLE_ROLE1", "ROLE_ROLE2", "ROLE_ROLE3" };
+		SimpleRoles2GrantedAuthoritiesMapper mapper = getDefaultMapper();
+		mapper.setAddPrefixIfAlreadyExisting(false);
+		mapper.setConvertRoleToUpperCase(true);
+		mapper.setRolePrefix("ROLE_");
+		testGetGrantedAuthorities(mapper, roles, expectedGas);
+	}
+
+	private void testGetGrantedAuthorities(SimpleRoles2GrantedAuthoritiesMapper mapper, String[] roles, String[] expectedGas) {
+		GrantedAuthority[] result = mapper.getGrantedAuthorities(roles);
+		Collection resultColl = new ArrayList(result.length);
+		for (int i = 0; i < result.length; i++) {
+			resultColl.add(result[i].getAuthority());
+		}
+		Collection expectedColl = Arrays.asList(expectedGas);
+		assertTrue("Role collections do not match; result: " + resultColl + ", expected: " + expectedColl, expectedColl
+				.containsAll(resultColl)
+				&& resultColl.containsAll(expectedColl));
+	}
+
+	private SimpleRoles2GrantedAuthoritiesMapper getDefaultMapper() {
+		SimpleRoles2GrantedAuthoritiesMapper mapper = new SimpleRoles2GrantedAuthoritiesMapper();
+		mapper.setRolePrefix("");
+		mapper.setConvertRoleToLowerCase(false);
+		mapper.setConvertRoleToUpperCase(false);
+		mapper.setAddPrefixIfAlreadyExisting(false);
+		return mapper;
+	}
+
+}
@@ -0,0 +1,100 @@
+package org.springframework.security.rolemapping;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.Collection;
+
+import junit.framework.TestCase;
+
+/**
+ * 
+ * @author TSARDD
+ * @since 18-okt-2007
+ */
+public class XmlMappableRolesRetrieverTests extends TestCase {
+	private static final String DEFAULT_XML = "<roles><role>Role1</role><role>Role2</role></roles>";
+
+	private static final String DEFAULT_XPATH = "/roles/role/text()";
+
+	private static final String[] DEFAULT_EXPECTED_ROLES = new String[] { "Role1", "Role2" };
+
+	public final void testAfterPropertiesSetException() {
+		TestXmlMappableRolesRetriever t = new TestXmlMappableRolesRetriever();
+		try {
+			t.afterPropertiesSet();
+			fail("AfterPropertiesSet didn't throw expected exception");
+		} catch (IllegalArgumentException expected) {
+		} catch (Exception unexpected) {
+			fail("AfterPropertiesSet throws unexpected exception");
+		}
+	}
+
+	public void testGetMappableRoles() {
+		XmlMappableRolesRetriever r = getXmlMappableRolesRetriever(true, getDefaultInputStream(), DEFAULT_XPATH);
+		String[] resultRoles = r.getMappableRoles();
+		assertNotNull("Result roles should not be null", resultRoles);
+		assertTrue("Number of result roles doesn't match expected number of roles", resultRoles.length == DEFAULT_EXPECTED_ROLES.length);
+		Collection resultRolesColl = Arrays.asList(resultRoles);
+		Collection expectedRolesColl = Arrays.asList(DEFAULT_EXPECTED_ROLES);
+		assertTrue("Role collections do not match", expectedRolesColl.containsAll(resultRolesColl)
+				&& resultRolesColl.containsAll(expectedRolesColl));
+	}
+
+	public void testCloseInputStream() {
+		testCloseInputStream(true);
+	}
+
+	public void testDontCloseInputStream() {
+		testCloseInputStream(false);
+	}
+
+	private void testCloseInputStream(boolean closeAfterRead) {
+		CloseableByteArrayInputStream is = getDefaultInputStream();
+		XmlMappableRolesRetriever r = getXmlMappableRolesRetriever(closeAfterRead, is, DEFAULT_XPATH);
+		r.getMappableRoles();
+		assertEquals(is.isClosed(), closeAfterRead);
+	}
+
+	private XmlMappableRolesRetriever getXmlMappableRolesRetriever(boolean closeInputStream, InputStream is, String xpath) {
+		XmlMappableRolesRetriever result = new TestXmlMappableRolesRetriever();
+		result.setCloseInputStream(closeInputStream);
+		result.setXmlInputStream(is);
+		result.setXpathExpression(xpath);
+		try {
+			result.afterPropertiesSet();
+		} catch (Exception e) {
+			fail("Unexpected exception" + e.toString());
+		}
+		return result;
+	}
+
+	private CloseableByteArrayInputStream getDefaultInputStream() {
+		return getInputStream(DEFAULT_XML);
+	}
+
+	private CloseableByteArrayInputStream getInputStream(String data) {
+		return new CloseableByteArrayInputStream(data.getBytes());
+	}
+
+	private static final class TestXmlMappableRolesRetriever extends XmlMappableRolesRetriever {
+	}
+
+	private static final class CloseableByteArrayInputStream extends ByteArrayInputStream {
+		private boolean closed = false;
+
+		public CloseableByteArrayInputStream(byte[] buf) {
+			super(buf);
+		}
+
+		public void close() throws IOException {
+			super.close();
+			closed = true;
+		}
+
+		public boolean isClosed() {
+			return closed;
+		}
+	}
+}
@@ -0,0 +1,72 @@
+package org.springframework.security.ui.preauth;
+
+import org.springframework.security.GrantedAuthorityImpl;
+import org.springframework.security.GrantedAuthority;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.servlet.http.HttpServletRequest;
+
+import junit.framework.TestCase;
+
+import org.apache.commons.lang.StringUtils;
+import org.springframework.mock.web.MockHttpServletRequest;
+
+/**
+ * 
+ * @author TSARDD
+ * @since 18-okt-2007
+ */
+public class PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetailsTests extends TestCase {
+
+    public final void testToString() {
+		PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails details = new PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails(
+				getRequest("testUser", new String[] {}));
+		GrantedAuthority[] gas = new GrantedAuthority[] { new GrantedAuthorityImpl("Role1"), new GrantedAuthorityImpl("Role2") };
+		details.setPreAuthenticatedGrantedAuthorities(gas);
+		String toString = details.toString();
+		assertTrue("toString doesn't contain Role1", StringUtils.contains(toString, "Role1"));
+		assertTrue("toString doesn't contain Role2", StringUtils.contains(toString, "Role2"));
+	}
+
+	public final void testGetSetPreAuthenticatedGrantedAuthorities() {
+		PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails details = new PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails(
+				getRequest("testUser", new String[] {}));
+		GrantedAuthority[] gas = new GrantedAuthority[] { new GrantedAuthorityImpl("Role1"), new GrantedAuthorityImpl("Role2") };
+		Collection expectedGas = Arrays.asList(gas);
+
+		details.setPreAuthenticatedGrantedAuthorities(gas);
+		Collection returnedGas = Arrays.asList(details.getPreAuthenticatedGrantedAuthorities());
+		assertTrue("Collections do not contain same elements; expected: " + expectedGas + ", returned: " + returnedGas, expectedGas
+				.containsAll(returnedGas)
+				&& returnedGas.containsAll(expectedGas));
+	}
+
+	public final void testGetWithoutSetPreAuthenticatedGrantedAuthorities() {
+		PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails details = new PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails(
+				getRequest("testUser", new String[] {}));
+		try {
+			GrantedAuthority[] gas = details.getPreAuthenticatedGrantedAuthorities();
+			fail("Expected exception didn't occur");
+		} catch (IllegalArgumentException expected) {
+		} catch (Exception unexpected) {
+			fail("Unexpected exception: " + unexpected.toString());
+		}
+	}
+	
+	private final HttpServletRequest getRequest(final String userName,final String[] aRoles)
+	{
+		MockHttpServletRequest req = new MockHttpServletRequest() {
+			private Set roles = new HashSet(Arrays.asList(aRoles));
+			public boolean isUserInRole(String arg0) {
+				return roles.contains(arg0);
+			}
+		};
+		req.setRemoteUser(userName);
+		return req;
+	}
+
+}
@@ -0,0 +1,42 @@
+package org.springframework.security.ui.preauth;
+
+import org.springframework.security.AuthenticationCredentialsNotFoundException;
+
+import java.io.IOException;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletResponse;
+
+import junit.framework.TestCase;
+
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpServletResponse;
+
+/**
+ * 
+ * @author TSARDD
+ * @since 18-okt-2007
+ */
+public class PreAuthenticatedProcesingFilterEntryPointTests extends TestCase {
+
+	public void testGetSetOrder() {
+		PreAuthenticatedProcesingFilterEntryPoint fep = new PreAuthenticatedProcesingFilterEntryPoint();
+		fep.setOrder(333);
+		assertEquals(fep.getOrder(), 333);
+	}
+	
+	public void testCommence() {
+		MockHttpServletRequest req = new MockHttpServletRequest();
+		MockHttpServletResponse resp = new MockHttpServletResponse();
+		PreAuthenticatedProcesingFilterEntryPoint fep = new PreAuthenticatedProcesingFilterEntryPoint();
+		try {
+			fep.commence(req,resp,new AuthenticationCredentialsNotFoundException("test"));
+			assertEquals("Incorrect status",resp.getStatus(),HttpServletResponse.SC_FORBIDDEN);
+		} catch (IOException e) {
+			fail("Unexpected exception thrown: "+e);
+		} catch (ServletException e) {
+			fail("Unexpected exception thrown: "+e);
+		}
+		
+	}
+}
@@ -0,0 +1,79 @@
+package org.springframework.security.ui.preauth;
+
+import org.springframework.security.context.SecurityContextHolder;
+import org.springframework.security.MockAuthenticationManager;
+
+import javax.servlet.http.HttpServletRequest;
+
+import junit.framework.TestCase;
+
+import org.springframework.mock.web.MockFilterChain;
+import org.springframework.mock.web.MockFilterConfig;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpServletResponse;
+
+public class PreAuthenticatedProcessingFilterTests extends TestCase {
+	protected void setUp() throws Exception {
+		SecurityContextHolder.clearContext();
+	}
+	
+	public void testAfterPropertiesSet()
+	{
+		ConcretePreAuthenticatedProcessingFilter filter = new ConcretePreAuthenticatedProcessingFilter();
+		try {
+			filter.afterPropertiesSet();
+			fail("AfterPropertiesSet didn't throw expected exception");
+		} catch (IllegalArgumentException expected) {
+		} catch (Exception unexpected) {
+			fail("AfterPropertiesSet throws unexpected exception");
+		}
+	}
+	
+	public void testInit() throws Exception
+	{
+		getFilter(true).init(new MockFilterConfig());
+		// Init doesn't do anything, so nothing to test
+	}
+	
+	public void testDestroy() throws Exception
+	{
+		getFilter(true).destroy();
+		// Destroy doesn't do anything, so nothing to test
+	}
+
+	public final void testDoFilterAuthenticated() throws Exception
+	{
+		testDoFilter(true);
+	}
+
+	public final void testDoFilterUnauthenticated() throws Exception
+	{
+		testDoFilter(false);
+	}
+	
+	private final void testDoFilter(boolean grantAccess) throws Exception
+	{
+		MockHttpServletRequest req = new MockHttpServletRequest();
+		MockHttpServletResponse res = new MockHttpServletResponse();
+		getFilter(grantAccess).doFilter(req,res,new MockFilterChain());
+		assertEquals(grantAccess,null!= SecurityContextHolder.getContext().getAuthentication());
+	}
+	
+	private static final ConcretePreAuthenticatedProcessingFilter getFilter(boolean grantAccess) throws Exception
+	{
+		ConcretePreAuthenticatedProcessingFilter filter = new ConcretePreAuthenticatedProcessingFilter();
+		filter.setAuthenticationManager(new MockAuthenticationManager(grantAccess));
+		filter.afterPropertiesSet();
+		return filter;
+	}
+	
+	private static final class ConcretePreAuthenticatedProcessingFilter extends AbstractPreAuthenticatedProcessingFilter
+	{
+		protected Object getPreAuthenticatedPrincipal(HttpServletRequest httpRequest) {
+			return "testPrincipal";
+		}
+		protected Object getPreAuthenticatedCredentials(HttpServletRequest httpRequest) {
+			return "testCredentials";
+		}
+	}
+}
@@ -0,0 +1,149 @@
+package org.springframework.security.ui.preauth.j2ee;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.servlet.http.HttpServletRequest;
+
+import junit.framework.TestCase;
+
+import org.springframework.security.rolemapping.MappableRolesRetriever;
+import org.springframework.security.rolemapping.Roles2GrantedAuthoritiesMapper;
+import org.springframework.security.rolemapping.SimpleMappableRolesRetriever;
+import org.springframework.security.rolemapping.SimpleRoles2GrantedAuthoritiesMapper;
+import org.springframework.security.ui.preauth.PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails;
+import org.springframework.security.GrantedAuthority;
+
+import org.springframework.mock.web.MockHttpServletRequest;
+
+/**
+ * 
+ * @author TSARDD
+ * @since 18-okt-2007
+ */
+public class J2eeBasedPreAuthenticatedWebAuthenticationDetailsSourceTests extends TestCase {
+
+	public final void testAfterPropertiesSetException() {
+		J2eeBasedPreAuthenticatedWebAuthenticationDetailsSource t = new J2eeBasedPreAuthenticatedWebAuthenticationDetailsSource();
+		try {
+			t.afterPropertiesSet();
+			fail("AfterPropertiesSet didn't throw expected exception");
+		} catch (IllegalArgumentException expected) {
+		} catch (Exception unexpected) {
+			fail("AfterPropertiesSet throws unexpected exception");
+		}
+	}
+
+	public final void testBuildDetailsHttpServletRequestNoMappedNoUserRoles() {
+		String[] mappedRoles = new String[] {};
+		String[] roles = new String[] {};
+		String[] expectedRoles = new String[] {};
+		testDetails(mappedRoles, roles, expectedRoles);
+	}
+
+	public final void testBuildDetailsHttpServletRequestNoMappedUnmappedUserRoles() {
+		String[] mappedRoles = new String[] {};
+		String[] roles = new String[] { "Role1", "Role2" };
+		String[] expectedRoles = new String[] {};
+		testDetails(mappedRoles, roles, expectedRoles);
+	}
+
+	public final void testBuildDetailsHttpServletRequestNoUserRoles() {
+		String[] mappedRoles = new String[] { "Role1", "Role2", "Role3", "Role4" };
+		String[] roles = new String[] {};
+		String[] expectedRoles = new String[] {};
+		testDetails(mappedRoles, roles, expectedRoles);
+	}
+
+	public final void testBuildDetailsHttpServletRequestAllUserRoles() {
+		String[] mappedRoles = new String[] { "Role1", "Role2", "Role3", "Role4" };
+		String[] roles = new String[] { "Role1", "Role2", "Role3", "Role4" };
+		String[] expectedRoles = new String[] { "Role1", "Role2", "Role3", "Role4" };
+		testDetails(mappedRoles, roles, expectedRoles);
+	}
+
+	public final void testBuildDetailsHttpServletRequestUnmappedUserRoles() {
+		String[] mappedRoles = new String[] { "Role1", "Role2", "Role3", "Role4" };
+		String[] roles = new String[] { "Role1", "Role2", "Role3", "Role4", "Role5" };
+		String[] expectedRoles = new String[] { "Role1", "Role2", "Role3", "Role4" };
+		testDetails(mappedRoles, roles, expectedRoles);
+	}
+
+	public final void testBuildDetailsHttpServletRequestPartialUserRoles() {
+		String[] mappedRoles = new String[] { "Role1", "Role2", "Role3", "Role4" };
+		String[] roles = new String[] { "Role2", "Role3" };
+		String[] expectedRoles = new String[] { "Role2", "Role3" };
+		testDetails(mappedRoles, roles, expectedRoles);
+	}
+
+	public final void testBuildDetailsHttpServletRequestPartialAndUnmappedUserRoles() {
+		String[] mappedRoles = new String[] { "Role1", "Role2", "Role3", "Role4" };
+		String[] roles = new String[] { "Role2", "Role3", "Role5" };
+		String[] expectedRoles = new String[] { "Role2", "Role3" };
+		testDetails(mappedRoles, roles, expectedRoles);
+	}
+
+	private void testDetails(String[] mappedRoles, String[] userRoles, String[] expectedRoles) {
+		J2eeBasedPreAuthenticatedWebAuthenticationDetailsSource src = getJ2eeBasedPreAuthenticatedWebAuthenticationDetailsSource(mappedRoles);
+		Object o = src.buildDetails(getRequest("testUser", userRoles));
+		assertNotNull(o);
+		assertTrue("Returned object not of type PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails, actual type: " + o.getClass(),
+				o instanceof PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails);
+		PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails details = (PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails) o;
+		GrantedAuthority[] gas = details.getPreAuthenticatedGrantedAuthorities();
+		assertNotNull("Granted authorities should not be null", gas);
+		assertTrue("Number of granted authorities should be " + expectedRoles.length, gas.length == expectedRoles.length);
+
+		Collection expectedRolesColl = Arrays.asList(expectedRoles);
+		Collection gasRolesSet = new HashSet();
+		for (int i = 0; i < gas.length; i++) {
+			gasRolesSet.add(gas[i].getAuthority());
+		}
+		assertTrue("Granted Authorities do not match expected roles", expectedRolesColl.containsAll(gasRolesSet)
+				&& gasRolesSet.containsAll(expectedRolesColl));
+	}
+
+	private final J2eeBasedPreAuthenticatedWebAuthenticationDetailsSource getJ2eeBasedPreAuthenticatedWebAuthenticationDetailsSource(
+			String[] mappedRoles) {
+		J2eeBasedPreAuthenticatedWebAuthenticationDetailsSource result = new J2eeBasedPreAuthenticatedWebAuthenticationDetailsSource();
+		result.setJ2eeMappableRolesRetriever(getMappableRolesRetriever(mappedRoles));
+		result.setJ2eeUserRoles2GrantedAuthoritiesMapper(getJ2eeUserRoles2GrantedAuthoritiesMapper());
+		result.setClazz(PreAuthenticatedGrantedAuthoritiesWebAuthenticationDetails.class);
+
+		try {
+			result.afterPropertiesSet();
+		} catch (Exception expected) {
+			fail("AfterPropertiesSet throws unexpected exception");
+		}
+		return result;
+	}
+
+	private MappableRolesRetriever getMappableRolesRetriever(String[] mappedRoles) {
+		SimpleMappableRolesRetriever result = new SimpleMappableRolesRetriever();
+		result.setMappableRoles(mappedRoles);
+		return result;
+	}
+
+	private Roles2GrantedAuthoritiesMapper getJ2eeUserRoles2GrantedAuthoritiesMapper() {
+		SimpleRoles2GrantedAuthoritiesMapper result = new SimpleRoles2GrantedAuthoritiesMapper();
+		result.setAddPrefixIfAlreadyExisting(false);
+		result.setConvertRoleToLowerCase(false);
+		result.setConvertRoleToUpperCase(false);
+		result.setRolePrefix("");
+		return result;
+	}
+	
+	private final HttpServletRequest getRequest(final String userName,final String[] aRoles)
+	{
+		MockHttpServletRequest req = new MockHttpServletRequest() {
+			private Set roles = new HashSet(Arrays.asList(aRoles));
+			public boolean isUserInRole(String arg0) {
+				return roles.contains(arg0);
+			}
+		};
+		req.setRemoteUser(userName);
+		return req;
+	}
+}
@@ -0,0 +1,49 @@
+package org.springframework.security.ui.preauth.j2ee;
+
+import java.security.Principal;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.servlet.http.HttpServletRequest;
+
+import junit.framework.TestCase;
+
+import org.springframework.mock.web.MockHttpServletRequest;
+
+/**
+ * 
+ * @author TSARDD
+ * @since 18-okt-2007
+ */
+public class J2eePreAuthenticatedProcessingFilterTests extends TestCase {
+
+    public final void testGetPreAuthenticatedPrincipal() {
+		String user = "testUser";
+		assertEquals(user, new J2eePreAuthenticatedProcessingFilter().getPreAuthenticatedPrincipal(
+			getRequest(user,new String[] {})));
+	}
+
+	public final void testGetPreAuthenticatedCredentials() {
+		assertEquals("N/A", new J2eePreAuthenticatedProcessingFilter().getPreAuthenticatedCredentials(
+			getRequest("testUser", new String[] {})));
+	}
+	
+	private final HttpServletRequest getRequest(final String aUserName,final String[] aRoles)
+	{
+		MockHttpServletRequest req = new MockHttpServletRequest() {
+			private Set roles = new HashSet(Arrays.asList(aRoles));
+			public boolean isUserInRole(String arg0) {
+				return roles.contains(arg0);
+			}
+		};
+		req.setRemoteUser(aUserName);
+		req.setUserPrincipal(new Principal() {
+			public String getName() {
+				return aUserName;
+			}
+		});
+		return req;
+	}
+
+}
@@ -0,0 +1,34 @@
+package org.springframework.security.ui.preauth.j2ee;
+
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.List;
+
+import junit.framework.TestCase;
+
+public class WebXmlJ2eeDefinedRolesRetrieverTests extends TestCase {
+
+	public final void testRole1To4Roles() throws Exception {
+		final List ROLE1TO4_EXPECTED_ROLES = Arrays.asList(new String[] { "Role1", "Role2", "Role3", "Role4" });
+		InputStream role1to4InputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("webxml/Role1-4.web.xml");
+		WebXmlMappableRolesRetriever rolesRetriever = new WebXmlMappableRolesRetriever();
+		rolesRetriever.setWebXmlInputStream(role1to4InputStream);
+		rolesRetriever.afterPropertiesSet();
+		String[] j2eeRoles = rolesRetriever.getMappableRoles();
+		assertNotNull(j2eeRoles);
+		List j2eeRolesList = Arrays.asList(j2eeRoles);
+		assertTrue("J2eeRoles expected size: " + ROLE1TO4_EXPECTED_ROLES.size() + ", actual size: " + j2eeRolesList.size(), j2eeRolesList
+				.size() == ROLE1TO4_EXPECTED_ROLES.size());
+		assertTrue("J2eeRoles expected contents (arbitrary order): " + ROLE1TO4_EXPECTED_ROLES + ", actual content: " + j2eeRolesList,
+				j2eeRolesList.containsAll(ROLE1TO4_EXPECTED_ROLES));
+	}
+
+	public final void testGetZeroJ2eeRoles() throws Exception {
+		InputStream noRolesInputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("webxml/NoRoles.web.xml");
+		WebXmlMappableRolesRetriever rolesRetriever = new WebXmlMappableRolesRetriever();
+		rolesRetriever.setWebXmlInputStream(noRolesInputStream);
+		rolesRetriever.afterPropertiesSet();
+		String[] j2eeRoles = rolesRetriever.getMappableRoles();
+		assertTrue("J2eeRoles expected size: 0, actual size: " + j2eeRoles.length, j2eeRoles.length == 0);
+	}
+}