Initial commit for captcha adapter

2005-07-19 12:35:50 +00:00
parent a67b529734
commit 3287439421
11 changed files with 2031 additions and 0 deletions
--- a/core/src/test/java/org/acegisecurity/captcha/CaptchaChannelProcessorTests.java
+++ b/core/src/test/java/org/acegisecurity/captcha/CaptchaChannelProcessorTests.java
@@ -0,0 +1,536 @@
+/* Copyright 2004 Acegi Technology Pty Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.sf.acegisecurity.captcha;
+
+import java.io.IOException;
+
+import javax.servlet.ServletException;
+
+import junit.framework.TestCase;
+import net.sf.acegisecurity.ConfigAttributeDefinition;
+import net.sf.acegisecurity.MockFilterChain;
+import net.sf.acegisecurity.SecurityConfig;
+import net.sf.acegisecurity.context.SecurityContextHolder;
+import net.sf.acegisecurity.intercept.web.FilterInvocation;
+
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpServletResponse;
+
+/** 
+ * Tests {@link CaptchaChannelProcessor} 
+ * @author marc antoine Garrigue
+ * @version $Id$
+ */
+public class CaptchaChannelProcessorTests extends TestCase {
+
+	public void testDecideRequestsFirstTestRequests() throws Exception {
+		ConfigAttributeDefinition cad = new ConfigAttributeDefinition();
+		cad.addConfigAttribute(new SecurityConfig("SOME_IGNORED_ATTRIBUTE"));
+		cad.addConfigAttribute(new SecurityConfig(
+				"REQUIRES_HUMAN_AFTER_MAX_REQUESTS"));
+
+		CaptchaSecurityContext context = new CaptchaSecurityContextImpl();
+		SecurityContextHolder.setContext(context);
+
+		CaptchaChannelProcessor processor = new CaptchaChannelProcessor();
+		CaptchaEntryPoint epoint = new CaptchaEntryPoint();
+		epoint.setCaptchaFormUrl("/jcaptcha.do");
+		processor.setEntryPoint(epoint);
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setQueryString("info=true");
+		request.setServerName("localhost");
+		request.setContextPath("/demo");
+		request.setServletPath("/restricted");
+		request.setScheme("http");
+		request.setServerPort(8000);
+
+		MockHttpServletResponse response = new MockHttpServletResponse();
+		MockFilterChain chain = new MockFilterChain();
+		FilterInvocation fi = new FilterInvocation(request, response, chain);
+
+		processor.decide(fi, cad);
+		assertEquals(response.getRedirectedUrl(),
+				"http://localhost:8000/demo/jcaptcha.do");
+
+		processor.setMaxRequestsBeforeFirstTest(1);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(response.getRedirectedUrl(), null);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(response.getRedirectedUrl(),
+				"http://localhost:8000/demo/jcaptcha.do");
+
+		processor.setMaxRequestsBeforeFirstTest(2);
+		processor.setMaxMillisBeforeReTest(0);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+	}
+
+	public void testDecideRequestsFirstTestMillis() throws Exception {
+		ConfigAttributeDefinition cad = new ConfigAttributeDefinition();
+		cad.addConfigAttribute(new SecurityConfig("SOME_IGNORED_ATTRIBUTE"));
+		cad.addConfigAttribute(new SecurityConfig(
+				"REQUIRES_HUMAN_AFTER_MAX_MILLIS"));
+
+		CaptchaSecurityContext context = new CaptchaSecurityContextImpl();
+		SecurityContextHolder.setContext(context);
+
+		CaptchaChannelProcessor processor = new CaptchaChannelProcessor();
+		CaptchaEntryPoint epoint = new CaptchaEntryPoint();
+		epoint.setCaptchaFormUrl("/jcaptcha.do");
+		processor.setEntryPoint(epoint);
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setQueryString("info=true");
+		request.setServerName("localhost");
+		request.setContextPath("/demo");
+		request.setServletPath("/restricted");
+		request.setScheme("http");
+		request.setServerPort(8000);
+
+		MockHttpServletResponse response = new MockHttpServletResponse();
+		MockFilterChain chain = new MockFilterChain();
+		FilterInvocation fi = new FilterInvocation(request, response, chain);
+
+		processor.decide(fi, cad);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		processor.setMaxRequestsBeforeFirstTest(1);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		processor.setMaxRequestsBeforeFirstTest(2);
+		processor.setMaxRequestsBeforeReTest(0);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+	}
+
+	public void testDecideRequestsReTest() throws Exception {
+		ConfigAttributeDefinition cad = new ConfigAttributeDefinition();
+		cad.addConfigAttribute(new SecurityConfig("SOME_IGNORED_ATTRIBUTE"));
+		cad.addConfigAttribute(new SecurityConfig(
+				"REQUIRES_HUMAN_AFTER_MAX_REQUESTS"));
+
+		CaptchaSecurityContext context = new CaptchaSecurityContextImpl();
+		SecurityContextHolder.setContext(context);
+
+		CaptchaChannelProcessor processor = new CaptchaChannelProcessor();
+		CaptchaEntryPoint epoint = new CaptchaEntryPoint();
+		epoint.setCaptchaFormUrl("/jcaptcha.do");
+		processor.setEntryPoint(epoint);
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setQueryString("info=true");
+		request.setServerName("localhost");
+		request.setContextPath("/demo");
+		request.setServletPath("/restricted");
+		request.setScheme("http");
+		request.setServerPort(8000);
+
+		MockHttpServletResponse response = new MockHttpServletResponse();
+		MockFilterChain chain = new MockFilterChain();
+		FilterInvocation fi = new FilterInvocation(request, response, chain);
+
+		processor.decide(fi, cad);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		processor.setMaxRequestsBeforeFirstTest(1);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(response.getRedirectedUrl(), null);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		processor.setMaxRequestsBeforeReTest(2);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		context.setHuman();
+		SecurityContextHolder.setContext(context);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		processor.setMaxMillisBeforeReTest(0);
+		context.setHuman();
+		SecurityContextHolder.setContext(context);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		context.setHuman();
+		SecurityContextHolder.setContext(context);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+	}
+
+	private MockHttpServletResponse decideWithNewResponse(
+			ConfigAttributeDefinition cad, CaptchaChannelProcessor processor,
+			MockHttpServletRequest request) throws IOException,
+			ServletException {
+		MockHttpServletResponse response;
+		MockFilterChain chain;
+		FilterInvocation fi;
+		response = new MockHttpServletResponse();
+		chain = new MockFilterChain();
+		fi = new FilterInvocation(request, response, chain);
+		processor.decide(fi, cad);
+		return response;
+	}
+
+	public void testDecideRejectsNulls() throws Exception {
+		CaptchaChannelProcessor processor = new CaptchaChannelProcessor();
+		processor.setEntryPoint(new CaptchaEntryPoint());
+		processor.afterPropertiesSet();
+
+		try {
+			processor.decide(null, null);
+			fail("Should have thrown IllegalArgumentException");
+		} catch (IllegalArgumentException expected) {
+			assertTrue(true);
+		}
+	}
+
+	public void testDecideMillis() throws Exception {
+		ConfigAttributeDefinition cad = new ConfigAttributeDefinition();
+		cad.addConfigAttribute(new SecurityConfig("SOME_IGNORED_ATTRIBUTE"));
+		cad.addConfigAttribute(new SecurityConfig(
+				"REQUIRES_HUMAN_AFTER_MAX_MILLIS"));
+
+		CaptchaSecurityContext context = new CaptchaSecurityContextImpl();
+		SecurityContextHolder.setContext(context);
+
+		CaptchaChannelProcessor processor = new CaptchaChannelProcessor();
+		CaptchaEntryPoint epoint = new CaptchaEntryPoint();
+		epoint.setCaptchaFormUrl("/jcaptcha.do");
+		processor.setEntryPoint(epoint);
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setQueryString("info=true");
+		request.setServerName("localhost");
+		request.setContextPath("/demo");
+		request.setServletPath("/restricted");
+		request.setScheme("http");
+		request.setServerPort(8000);
+
+		MockHttpServletResponse response = new MockHttpServletResponse();
+		MockFilterChain chain = new MockFilterChain();
+		FilterInvocation fi = new FilterInvocation(request, response, chain);
+
+		processor.decide(fi, cad);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		processor.setMaxRequestsBeforeFirstTest(1);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(response.getRedirectedUrl(), null);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		processor.setMaxMillisBeforeReTest(100);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		context.setHuman();
+		SecurityContextHolder.setContext(context);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		Thread.sleep(100);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		processor.setMaxRequestsBeforeReTest(0);
+		context.setHuman();
+		SecurityContextHolder.setContext(context);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		Thread.sleep(100);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		context.setHuman();
+		SecurityContextHolder.setContext(context);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		Thread.sleep(100);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+	}
+
+	public void testDecideBoth() throws Exception {
+		ConfigAttributeDefinition cad = new ConfigAttributeDefinition();
+		cad.addConfigAttribute(new SecurityConfig("SOME_IGNORED_ATTRIBUTE"));
+		cad.addConfigAttribute(new SecurityConfig(
+				"REQUIRES_HUMAN_AFTER_MAX_MILLIS"));
+		cad.addConfigAttribute(new SecurityConfig(
+				"REQUIRES_HUMAN_AFTER_MAX_REQUESTS"));
+
+		CaptchaSecurityContext context = new CaptchaSecurityContextImpl();
+		SecurityContextHolder.setContext(context);
+
+		CaptchaChannelProcessor processor = new CaptchaChannelProcessor();
+		CaptchaEntryPoint epoint = new CaptchaEntryPoint();
+		epoint.setCaptchaFormUrl("/jcaptcha.do");
+		processor.setEntryPoint(epoint);
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setQueryString("info=true");
+		request.setServerName("localhost");
+		request.setContextPath("/demo");
+		request.setServletPath("/restricted");
+		request.setScheme("http");
+		request.setServerPort(8000);
+
+		MockHttpServletResponse response = new MockHttpServletResponse();
+		MockFilterChain chain = new MockFilterChain();
+		FilterInvocation fi = new FilterInvocation(request, response, chain);
+
+		processor.decide(fi, cad);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		processor.setMaxRequestsBeforeFirstTest(1);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(response.getRedirectedUrl(), null);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		processor.setMaxMillisBeforeReTest(100);
+		processor.setMaxRequestsBeforeReTest(2);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		context.setHuman();
+		SecurityContextHolder.setContext(context);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		Thread.sleep(100);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		context.setHuman();
+		SecurityContextHolder.setContext(context);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		context.setHuman();
+		SecurityContextHolder.setContext(context);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals(null, response.getRedirectedUrl());
+
+		Thread.sleep(100);
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+
+		response = decideWithNewResponse(cad, processor, request);
+		assertEquals("http://localhost:8000/demo/jcaptcha.do", response
+				.getRedirectedUrl());
+	}
+
+	public void testGettersSetters() {
+		CaptchaChannelProcessor processor = new CaptchaChannelProcessor();
+		assertEquals("REQUIRES_HUMAN_AFTER_MAX_MILLIS", processor
+				.getRequiresHumanAfterMaxMillisKeyword());
+		processor.setRequiresHumanAfterMaxMillisKeyword("X");
+		assertEquals("X", processor.getRequiresHumanAfterMaxMillisKeyword());
+
+		assertEquals("REQUIRES_HUMAN_AFTER_MAX_REQUESTS", processor
+				.getRequiresHumanAfterMaxRequestsKeyword());
+		processor.setRequiresHumanAfterMaxRequestsKeyword("Y");
+		assertEquals("Y", processor.getRequiresHumanAfterMaxRequestsKeyword());
+
+		assertEquals(0, processor.getMaxRequestsBeforeFirstTest());
+		processor.setMaxRequestsBeforeFirstTest(1);
+		assertEquals(1, processor.getMaxRequestsBeforeFirstTest());
+
+		assertEquals(-1, processor.getMaxRequestsBeforeReTest());
+		processor.setMaxRequestsBeforeReTest(11);
+		assertEquals(11, processor.getMaxRequestsBeforeReTest());
+
+		assertEquals(-1, processor.getMaxMillisBeforeReTest());
+		processor.setMaxMillisBeforeReTest(111);
+		assertEquals(111, processor.getMaxMillisBeforeReTest());
+
+		assertTrue(processor.getEntryPoint() == null);
+		processor.setEntryPoint(new CaptchaEntryPoint());
+		assertTrue(processor.getEntryPoint() != null);
+	}
+
+	public void testMissingEntryPoint() throws Exception {
+		CaptchaChannelProcessor processor = new CaptchaChannelProcessor();
+		processor.setEntryPoint(null);
+
+		try {
+			processor.afterPropertiesSet();
+			fail("Should have thrown IllegalArgumentException");
+		} catch (IllegalArgumentException expected) {
+			assertEquals("entryPoint required", expected.getMessage());
+		}
+	}
+
+	public void testMissingKeyword() throws Exception {
+		CaptchaChannelProcessor processor = new CaptchaChannelProcessor();
+		processor.setRequiresHumanAfterMaxMillisKeyword(null);
+
+		try {
+			processor.afterPropertiesSet();
+			fail("Should have thrown IllegalArgumentException");
+		} catch (IllegalArgumentException expected) {
+
+		}
+		processor.setRequiresHumanAfterMaxMillisKeyword("");
+
+		try {
+			processor.afterPropertiesSet();
+			fail("Should have thrown IllegalArgumentException");
+		} catch (IllegalArgumentException expected) {
+
+		}
+		processor.setRequiresHumanAfterMaxRequestsKeyword("");
+
+		try {
+			processor.afterPropertiesSet();
+			fail("Should have thrown IllegalArgumentException");
+		} catch (IllegalArgumentException expected) {
+
+		}
+
+		processor.setRequiresHumanAfterMaxRequestsKeyword(null);
+
+		try {
+			processor.afterPropertiesSet();
+			fail("Should have thrown IllegalArgumentException");
+		} catch (IllegalArgumentException expected) {
+
+		}
+
+	}
+
+	public void testSupports() {
+		CaptchaChannelProcessor processor = new CaptchaChannelProcessor();
+		assertTrue(processor.supports(new SecurityConfig(processor
+				.getRequiresHumanAfterMaxMillisKeyword())));
+		assertTrue(processor.supports(new SecurityConfig(processor
+				.getRequiresHumanAfterMaxRequestsKeyword())));
+
+		assertTrue(processor.supports(new SecurityConfig(
+				"REQUIRES_HUMAN_AFTER_MAX_REQUESTS")));
+		assertTrue(processor.supports(new SecurityConfig(
+				"REQUIRES_HUMAN_AFTER_MAX_MILLIS")));
+
+		assertFalse(processor.supports(null));
+
+		assertFalse(processor.supports(new SecurityConfig("NOT_SUPPORTED")));
+	}
+
+}
--- a/core/src/test/java/org/acegisecurity/captcha/CaptchaEntryPointTests.java
+++ b/core/src/test/java/org/acegisecurity/captcha/CaptchaEntryPointTests.java
@@ -0,0 +1,385 @@
+/* Copyright 2004 Acegi Technology Pty Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.sf.acegisecurity.captcha;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import junit.framework.TestCase;
+import net.sf.acegisecurity.MockPortResolver;
+import net.sf.acegisecurity.securechannel.RetryWithHttpEntryPoint;
+import net.sf.acegisecurity.util.PortMapperImpl;
+
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpServletResponse;
+
+/**
+ * Tests {@link RetryWithHttpEntryPoint}.
+ * 
+ * @author Ben Alex
+ * @version $Id: RetryWithHttpEntryPointTests.java,v 1.4 2005/04/11 01:07:02
+ *          luke_t Exp $
+ */
+public class CaptchaEntryPointTests extends TestCase {
+	// ~ Methods
+	// ================================================================
+
+	public final void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public static void main(String[] args) {
+		junit.textui.TestRunner.run(CaptchaEntryPointTests.class);
+	}
+
+	public void testDetectsMissingCaptchaFormUrl() throws Exception {
+		CaptchaEntryPoint ep = new CaptchaEntryPoint();
+		ep.setPortMapper(new PortMapperImpl());
+		ep.setPortResolver(new MockPortResolver(80, 443));
+
+		try {
+			ep.afterPropertiesSet();
+			fail("Should have thrown IllegalArgumentException");
+		} catch (IllegalArgumentException expected) {
+			assertEquals("captchaFormUrl must be specified", expected
+					.getMessage());
+		}
+	}
+
+	public void testDetectsMissingPortMapper() throws Exception {
+		CaptchaEntryPoint ep = new CaptchaEntryPoint();
+		ep.setCaptchaFormUrl("xxx");
+		ep.setPortMapper(null);
+
+		try {
+			ep.afterPropertiesSet();
+			fail("Should have thrown IllegalArgumentException");
+		} catch (IllegalArgumentException expected) {
+			assertEquals("portMapper must be specified", expected.getMessage());
+		}
+	}
+
+	public void testDetectsMissingPortResolver() throws Exception {
+		CaptchaEntryPoint ep = new CaptchaEntryPoint();
+		ep.setCaptchaFormUrl("xxx");
+		ep.setPortResolver(null);
+
+		try {
+			ep.afterPropertiesSet();
+			fail("Should have thrown IllegalArgumentException");
+		} catch (IllegalArgumentException expected) {
+			assertEquals("portResolver must be specified", expected
+					.getMessage());
+		}
+
+	}
+
+	public void testGettersSetters() {
+		CaptchaEntryPoint ep = new CaptchaEntryPoint();
+		ep.setCaptchaFormUrl("/hello");
+		ep.setPortMapper(new PortMapperImpl());
+		ep.setPortResolver(new MockPortResolver(8080, 8443));
+		assertEquals("/hello", ep.getCaptchaFormUrl());
+		assertTrue(ep.getPortMapper() != null);
+		assertTrue(ep.getPortResolver() != null);
+
+		assertEquals("originalRequest", ep.getOriginalRequestParameterName());
+		ep.setOriginalRequestParameterName("Z");
+		assertEquals("Z", ep.getOriginalRequestParameterName());
+
+		assertEquals(false, ep.isIncludeOriginalRequest());
+		ep.setIncludeOriginalRequest(true);
+		assertEquals(true, ep.isIncludeOriginalRequest());
+
+		assertEquals(false, ep.isOutsideWebApp());
+		ep.setOutsideWebApp(true);
+		assertEquals(true, ep.isOutsideWebApp());
+
+		ep.setForceHttps(false);
+		assertFalse(ep.getForceHttps());
+		ep.setForceHttps(true);
+		assertTrue(ep.getForceHttps());
+
+	}
+
+	public void testHttpsOperationFromOriginalHttpUrl() throws Exception {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setRequestURI("/some_path");
+		request.setScheme("http");
+		request.setServerName("www.example.com");
+		request.setContextPath("/bigWebApp");
+		request.setServerPort(80);
+
+		MockHttpServletResponse response = new MockHttpServletResponse();
+
+		CaptchaEntryPoint ep = new CaptchaEntryPoint();
+		ep.setCaptchaFormUrl("/hello");
+		ep.setPortMapper(new PortMapperImpl());
+		ep.setForceHttps(true);
+		ep.setPortMapper(new PortMapperImpl());
+		ep.setPortResolver(new MockPortResolver(80, 443));
+		ep.afterPropertiesSet();
+
+		ep.commence(request, response);
+		assertEquals("https://www.example.com/bigWebApp/hello", response
+				.getRedirectedUrl());
+
+		request.setServerPort(8080);
+		response = new MockHttpServletResponse();
+		ep.setPortResolver(new MockPortResolver(8080, 8443));
+		ep.commence(request, response);
+		assertEquals("https://www.example.com:8443/bigWebApp/hello", response
+				.getRedirectedUrl());
+
+		// Now test an unusual custom HTTP:HTTPS is handled properly
+		request.setServerPort(8888);
+		response = new MockHttpServletResponse();
+		ep.commence(request, response);
+		assertEquals("https://www.example.com:8443/bigWebApp/hello", response
+				.getRedirectedUrl());
+
+		PortMapperImpl portMapper = new PortMapperImpl();
+		Map map = new HashMap();
+		map.put("8888", "9999");
+		portMapper.setPortMappings(map);
+		response = new MockHttpServletResponse();
+
+		ep = new CaptchaEntryPoint();
+		ep.setCaptchaFormUrl("/hello");
+		ep.setPortMapper(new PortMapperImpl());
+		ep.setForceHttps(true);
+		ep.setPortMapper(portMapper);
+		ep.setPortResolver(new MockPortResolver(8888, 9999));
+		ep.afterPropertiesSet();
+
+		ep.commence(request, response);
+		assertEquals("https://www.example.com:9999/bigWebApp/hello", response
+				.getRedirectedUrl());
+	}
+
+	public void testHttpsOperationFromOriginalHttpsUrl() throws Exception {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setRequestURI("/some_path");
+		request.setScheme("https");
+		request.setServerName("www.example.com");
+		request.setContextPath("/bigWebApp");
+		request.setServerPort(443);
+
+		MockHttpServletResponse response = new MockHttpServletResponse();
+
+		CaptchaEntryPoint ep = new CaptchaEntryPoint();
+		ep.setCaptchaFormUrl("/hello");
+		ep.setPortMapper(new PortMapperImpl());
+		ep.setForceHttps(true);
+		ep.setPortMapper(new PortMapperImpl());
+		ep.setPortResolver(new MockPortResolver(80, 443));
+		ep.afterPropertiesSet();
+
+		ep.commence(request, response);
+		assertEquals("https://www.example.com/bigWebApp/hello", response
+				.getRedirectedUrl());
+
+		request.setServerPort(8443);
+		response = new MockHttpServletResponse();
+		ep.setPortResolver(new MockPortResolver(8080, 8443));
+		ep.commence(request, response);
+		assertEquals("https://www.example.com:8443/bigWebApp/hello", response
+				.getRedirectedUrl());
+	}
+
+	public void testNormalOperation() throws Exception {
+		CaptchaEntryPoint ep = new CaptchaEntryPoint();
+		ep.setCaptchaFormUrl("/hello");
+		ep.setPortMapper(new PortMapperImpl());
+		ep.setPortResolver(new MockPortResolver(80, 443));
+		ep.afterPropertiesSet();
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setRequestURI("/some_path");
+		request.setContextPath("/bigWebApp");
+		request.setScheme("http");
+		request.setServerName("www.example.com");
+		request.setContextPath("/bigWebApp");
+		request.setServerPort(80);
+
+		MockHttpServletResponse response = new MockHttpServletResponse();
+
+		ep.afterPropertiesSet();
+		ep.commence(request, response);
+		assertEquals("http://www.example.com/bigWebApp/hello", response
+				.getRedirectedUrl());
+	}
+
+	public void testOperationWhenHttpsRequestsButHttpsPortUnknown()
+			throws Exception {
+		CaptchaEntryPoint ep = new CaptchaEntryPoint();
+		ep.setCaptchaFormUrl("/hello");
+		ep.setPortMapper(new PortMapperImpl());
+		ep.setPortResolver(new MockPortResolver(8888, 1234));
+		ep.setForceHttps(true);
+		ep.afterPropertiesSet();
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setRequestURI("/some_path");
+		request.setContextPath("/bigWebApp");
+		request.setScheme("http");
+		request.setServerName("www.example.com");
+		request.setContextPath("/bigWebApp");
+		request.setServerPort(8888); // NB: Port we can't resolve
+
+		MockHttpServletResponse response = new MockHttpServletResponse();
+
+		ep.afterPropertiesSet();
+		ep.commence(request, response);
+
+		// Response doesn't switch to HTTPS, as we didn't know HTTP port 8888 to
+		// HTTP port mapping
+		assertEquals("http://www.example.com:8888/bigWebApp/hello", response
+				.getRedirectedUrl());
+	}
+
+	public void testOperationWithOriginalRequestIncludes() throws Exception {
+		CaptchaEntryPoint ep = new CaptchaEntryPoint();
+		ep.setCaptchaFormUrl("/hello");
+		PortMapperImpl mapper = new PortMapperImpl();
+		mapper.getTranslatedPortMappings().put(new Integer(8888),
+				new Integer(1234));
+		ep.setPortMapper(mapper);
+
+		ep.setPortResolver(new MockPortResolver(8888, 1234));
+		ep.setIncludeOriginalRequest(true);
+		ep.afterPropertiesSet();
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setRequestURI("/some_path");
+		request.setScheme("http");
+		request.setServerName("www.example.com");
+		// request.setContextPath("/bigWebApp");
+		// TODO correct this when the getRequestUrl from mock works...
+
+		request.setServerPort(8888); // NB: Port we can't resolve
+
+		MockHttpServletResponse response = new MockHttpServletResponse();
+
+		ep.afterPropertiesSet();
+		ep.commence(request, response);
+		assertEquals(
+				"http://www.example.com:8888/hello?originalRequest=http://www.example.com:8888/some_path",
+				response.getRedirectedUrl());
+
+		// test the query params
+		request.addParameter("name", "value");
+		response = new MockHttpServletResponse();
+		ep.commence(request, response);
+		assertEquals(
+				"http://www.example.com:8888/hello?originalRequest=http://www.example.com:8888/some_path?name=value",
+				response.getRedirectedUrl());
+
+		// test the multiple query params
+		request.addParameter("name", "value");
+		request.addParameter("name1", "value2");
+		response = new MockHttpServletResponse();
+		ep.commence(request, response);
+		assertEquals(
+				"http://www.example.com:8888/hello?originalRequest=http://www.example.com:8888/some_path?name=value&name1=value2",
+				response.getRedirectedUrl());
+
+		// test add parameter to captcha form url??
+
+		ep.setCaptchaFormUrl("/hello?toto=titi");
+		response = new MockHttpServletResponse();
+		ep.commence(request, response);
+		assertEquals(
+				"http://www.example.com:8888/hello?toto=titi&originalRequest=http://www.example.com:8888/some_path?name=value&name1=value2",
+				response.getRedirectedUrl());
+
+		// with forcing!!!
+		ep.setForceHttps(true);
+		response = new MockHttpServletResponse();
+		ep.commence(request, response);
+		assertEquals(
+				"https://www.example.com:1234/hello?toto=titi&originalRequest=http://www.example.com:8888/some_path?name=value&name1=value2",
+				response.getRedirectedUrl());
+
+	}
+
+	public void testOperationWithOutsideWebApp() throws Exception {
+		CaptchaEntryPoint ep = new CaptchaEntryPoint();
+		ep.setCaptchaFormUrl("https://www.jcaptcha.net/dotest/");
+		PortMapperImpl mapper = new PortMapperImpl();
+		mapper.getTranslatedPortMappings().put(new Integer(8888),
+				new Integer(1234));
+		ep.setPortMapper(mapper);
+
+		ep.setPortResolver(new MockPortResolver(8888, 1234));
+		ep.setIncludeOriginalRequest(true);
+		ep.setOutsideWebApp(true);
+
+		ep.afterPropertiesSet();
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setRequestURI("/some_path");
+		request.setScheme("http");
+		request.setServerName("www.example.com");
+		// request.setContextPath("/bigWebApp");
+		// TODO correct this when the getRequestUrl from mock works...
+
+		request.setServerPort(8888); // NB: Port we can't resolve
+
+		MockHttpServletResponse response = new MockHttpServletResponse();
+
+		ep.afterPropertiesSet();
+		ep.commence(request, response);
+		assertEquals(
+				"https://www.jcaptcha.net/dotest/?originalRequest=http://www.example.com:8888/some_path",
+				response.getRedirectedUrl());
+
+		// test the query params
+		request.addParameter("name", "value");
+		response = new MockHttpServletResponse();
+		ep.commence(request, response);
+		assertEquals(
+				"https://www.jcaptcha.net/dotest/?originalRequest=http://www.example.com:8888/some_path?name=value",
+				response.getRedirectedUrl());
+
+		// test the multiple query params
+		request.addParameter("name", "value");
+		request.addParameter("name1", "value2");
+		response = new MockHttpServletResponse();
+		ep.commence(request, response);
+		assertEquals(
+				"https://www.jcaptcha.net/dotest/?originalRequest=http://www.example.com:8888/some_path?name=value&name1=value2",
+				response.getRedirectedUrl());
+
+		// test add parameter to captcha form url??
+
+		ep.setCaptchaFormUrl("https://www.jcaptcha.net/dotest/?toto=titi");
+		response = new MockHttpServletResponse();
+		ep.commence(request, response);
+		assertEquals(
+				"https://www.jcaptcha.net/dotest/?toto=titi&originalRequest=http://www.example.com:8888/some_path?name=value&name1=value2",
+				response.getRedirectedUrl());
+
+		// with forcing!!!
+		ep.setForceHttps(true);
+		response = new MockHttpServletResponse();
+		ep.commence(request, response);
+		assertEquals(
+				"https://www.jcaptcha.net/dotest/?toto=titi&originalRequest=http://www.example.com:8888/some_path?name=value&name1=value2",
+				response.getRedirectedUrl());
+
+	}
+
+}
--- a/core/src/test/java/org/acegisecurity/captcha/CaptchaSecurityContextImplTests.java
+++ b/core/src/test/java/org/acegisecurity/captcha/CaptchaSecurityContextImplTests.java
@@ -0,0 +1,64 @@
+package net.sf.acegisecurity.captcha;
+
+import net.sf.acegisecurity.context.SecurityContextImplTests;
+
+public class CaptchaSecurityContextImplTests extends SecurityContextImplTests {
+
+	public void testDefaultValues() {
+		CaptchaSecurityContext context = new CaptchaSecurityContextImpl();
+		assertEquals("should not be human", false, context.isHuman());
+		assertEquals("should be 0", 0, context
+				.getLastPassedCaptchaDateInMillis());
+		assertEquals("should be 0", 0, context
+				.getHumanRestrictedResourcesRequestsCount());
+	}
+
+	public void testSetHuman() {
+		CaptchaSecurityContext context = new CaptchaSecurityContextImpl();
+		long now = System.currentTimeMillis();
+		context.setHuman();
+		assertEquals("should be human", true, context.isHuman());
+		assertTrue("should be more than 0", context
+				.getLastPassedCaptchaDateInMillis()
+				- now >= 0);
+		assertTrue("should be less than 0,1 seconde", context
+				.getLastPassedCaptchaDateInMillis()
+				- now < 100);
+		assertEquals("should be 0", 0, context
+				.getHumanRestrictedResourcesRequestsCount());
+	}
+
+	public void testIncrementRequests() {
+		CaptchaSecurityContext context = new CaptchaSecurityContextImpl();
+		context.setHuman();
+		assertEquals("should be human", true, context.isHuman());
+		assertEquals("should be 0", 0, context
+				.getHumanRestrictedResourcesRequestsCount());
+		context.incrementHumanRestrictedRessoucesRequestsCount();
+		assertEquals("should be 1", 1, context
+				.getHumanRestrictedResourcesRequestsCount());
+	}
+
+	public void testResetHuman() {
+		CaptchaSecurityContext context = new CaptchaSecurityContextImpl();
+		context.setHuman();
+		assertEquals("should be human", true, context.isHuman());
+		assertEquals("should be 0", 0, context
+				.getHumanRestrictedResourcesRequestsCount());
+		context.incrementHumanRestrictedRessoucesRequestsCount();
+		assertEquals("should be 1", 1, context
+				.getHumanRestrictedResourcesRequestsCount());
+		long now = System.currentTimeMillis();
+		context.setHuman();
+		assertEquals("should be 0", 0, context
+				.getHumanRestrictedResourcesRequestsCount());
+		assertTrue("should be more than 0", context
+				.getLastPassedCaptchaDateInMillis()
+				- now >= 0);
+		assertTrue("should be less than 0,1 seconde", context
+				.getLastPassedCaptchaDateInMillis()
+				- now < 100);
+
+	}
+
+}
--- a/core/src/test/java/org/acegisecurity/captcha/CaptchaValidationProcessingFilterTests.java
+++ b/core/src/test/java/org/acegisecurity/captcha/CaptchaValidationProcessingFilterTests.java
@@ -0,0 +1,83 @@
+package net.sf.acegisecurity.captcha;
+
+import junit.framework.TestCase;
+import net.sf.acegisecurity.context.SecurityContextHolder;
+import net.sf.acegisecurity.util.MockFilterChain;
+
+import org.springframework.mock.web.MockHttpServletRequest;
+
+public class CaptchaValidationProcessingFilterTests extends TestCase {
+
+	/*
+	 */
+	public void testAfterPropertiesSet() throws Exception {
+		CaptchaValidationProcessingFilter filter = new CaptchaValidationProcessingFilter();
+
+		try {
+			filter.afterPropertiesSet();
+			fail("should have thrown an invalid argument exception");
+		} catch (Exception e) {
+			assertTrue("should be an InvalidArgumentException",
+					IllegalArgumentException.class.isAssignableFrom(e
+							.getClass()));
+		}
+		filter.setCaptchaService(new MockCaptchaServiceProxy());
+		filter.afterPropertiesSet();
+
+	}
+
+	/*
+	 * Test method for
+	 * 'net.sf.acegisecurity.captcha.CaptchaValidationProcessingFilter.doFilter(ServletRequest,
+	 * ServletResponse, FilterChain)'
+	 */
+	public void testDoFilterWithoutRequestParameter() throws Exception {
+		CaptchaSecurityContext context = new CaptchaSecurityContextImpl();
+		SecurityContextHolder.setContext(context);
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		CaptchaValidationProcessingFilter filter = new CaptchaValidationProcessingFilter();
+		MockCaptchaServiceProxy service = new MockCaptchaServiceProxy();
+		MockFilterChain chain = new MockFilterChain(true);
+		filter.setCaptchaService(service);
+		filter.doFilter(request, null, chain);
+		assertFalse("proxy should not have been called", service.hasBeenCalled);
+		assertFalse("context should not have been updated", context.isHuman());
+		// test with valid
+		service.valid = true;
+		filter.doFilter(request, null, chain);
+		assertFalse("proxy should not have been called", service.hasBeenCalled);
+		assertFalse("context should not have been updated", context.isHuman());
+
+	}
+
+	/*
+	 * Test method for
+	 * 'net.sf.acegisecurity.captcha.CaptchaValidationProcessingFilter.doFilter(ServletRequest,
+	 * ServletResponse, FilterChain)'
+	 */
+	public void testDoFilterWithRequestParameter() throws Exception {
+		CaptchaSecurityContext context = new CaptchaSecurityContextImpl();
+		SecurityContextHolder.setContext(context);
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request
+				.addParameter(
+						CaptchaValidationProcessingFilter.CAPTCHA_VALIDATION_SECURITY_PARAMETER_KEY,
+						"");
+
+		CaptchaValidationProcessingFilter filter = new CaptchaValidationProcessingFilter();
+		MockCaptchaServiceProxy service = new MockCaptchaServiceProxy();
+		MockFilterChain chain = new MockFilterChain(true);
+		filter.setCaptchaService(service);
+		filter.doFilter(request, null, chain);
+		assertTrue("should have been called", service.hasBeenCalled);
+		assertFalse("context should not have been updated", context.isHuman());
+		// test with valid
+		service.valid = true;
+		filter.doFilter(request, null, chain);
+		assertTrue("should have been called", service.hasBeenCalled);
+		assertTrue("context should have been updated", context.isHuman());
+
+	}
+
+}
--- a/core/src/test/java/org/acegisecurity/captcha/MockCaptchaServiceProxy.java
+++ b/core/src/test/java/org/acegisecurity/captcha/MockCaptchaServiceProxy.java
@@ -0,0 +1,32 @@
+/* Copyright 2004 Acegi Technology Pty Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.sf.acegisecurity.captcha;
+
+import javax.servlet.ServletRequest;
+
+public class MockCaptchaServiceProxy implements CaptchaServiceProxy {
+
+	public boolean valid = false;
+
+	public boolean hasBeenCalled = false;
+
+	public boolean validateRequest(ServletRequest request) {
+		hasBeenCalled = true;
+		return valid;
+
+	}
+
+}