001: /* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
002: *
003: * Licensed under the Apache License, Version 2.0 (the "License");
004: * you may not use this file except in compliance with the License.
005: * You may obtain a copy of the License at
006: *
007: * http://www.apache.org/licenses/LICENSE-2.0
008: *
009: * Unless required by applicable law or agreed to in writing, software
010: * distributed under the License is distributed on an "AS IS" BASIS,
011: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
012: * See the License for the specific language governing permissions and
013: * limitations under the License.
014: */
015:
016: package org.acegisecurity.securechannel;
017:
018: import junit.framework.TestCase;
019:
020: import org.acegisecurity.ConfigAttribute;
021: import org.acegisecurity.ConfigAttributeDefinition;
022: import org.acegisecurity.SecurityConfig;
023:
024: import org.acegisecurity.intercept.web.FilterInvocation;
025: import org.acegisecurity.intercept.web.FilterInvocationDefinitionSource;
026:
027: import org.springframework.mock.web.MockHttpServletRequest;
028: import org.springframework.mock.web.MockHttpServletResponse;
029:
030: import java.io.IOException;
031:
032: import java.util.Iterator;
033: import java.util.List;
034: import java.util.Vector;
035:
036: import javax.servlet.FilterChain;
037: import javax.servlet.ServletException;
038: import javax.servlet.ServletRequest;
039: import javax.servlet.ServletResponse;
040:
041: /**
042: * Tests {@link ChannelProcessingFilter}.
043: *
044: * @author Ben Alex
045: * @version $Id: ChannelProcessingFilterTests.java 1496 2006-05-23 13:38:33Z benalex $
046: */
047: public class ChannelProcessingFilterTests extends TestCase {
048: //~ Methods ========================================================================================================
049:
050: public static void main(String[] args) {
051: junit.textui.TestRunner.run(ChannelProcessingFilterTests.class);
052: }
053:
054: public final void setUp() throws Exception {
055: super .setUp();
056: }
057:
058: public void testDetectsMissingChannelDecisionManager()
059: throws Exception {
060: ChannelProcessingFilter filter = new ChannelProcessingFilter();
061:
062: ConfigAttributeDefinition attr = new ConfigAttributeDefinition();
063: attr.addConfigAttribute(new SecurityConfig("MOCK"));
064:
065: MockFilterInvocationDefinitionMap fids = new MockFilterInvocationDefinitionMap(
066: "/path", attr, true);
067: filter.setFilterInvocationDefinitionSource(fids);
068:
069: try {
070: filter.afterPropertiesSet();
071: fail("Should have thrown IllegalArgumentException");
072: } catch (IllegalArgumentException expected) {
073: assertEquals("channelDecisionManager must be specified",
074: expected.getMessage());
075: }
076: }
077:
078: public void testDetectsMissingFilterInvocationDefinitionSource()
079: throws Exception {
080: ChannelProcessingFilter filter = new ChannelProcessingFilter();
081: filter
082: .setChannelDecisionManager(new MockChannelDecisionManager(
083: false, "MOCK"));
084:
085: try {
086: filter.afterPropertiesSet();
087: fail("Should have thrown IllegalArgumentException");
088: } catch (IllegalArgumentException expected) {
089: assertEquals(
090: "filterInvocationDefinitionSource must be specified",
091: expected.getMessage());
092: }
093: }
094:
095: public void testDetectsSupportedConfigAttribute() throws Exception {
096: ChannelProcessingFilter filter = new ChannelProcessingFilter();
097: filter
098: .setChannelDecisionManager(new MockChannelDecisionManager(
099: false, "SUPPORTS_MOCK_ONLY"));
100:
101: ConfigAttributeDefinition attr = new ConfigAttributeDefinition();
102: attr
103: .addConfigAttribute(new SecurityConfig(
104: "SUPPORTS_MOCK_ONLY"));
105:
106: MockFilterInvocationDefinitionMap fids = new MockFilterInvocationDefinitionMap(
107: "/path", attr, true);
108:
109: filter.setFilterInvocationDefinitionSource(fids);
110:
111: filter.afterPropertiesSet();
112: assertTrue(true);
113: }
114:
115: public void testDetectsUnsupportedConfigAttribute()
116: throws Exception {
117: ChannelProcessingFilter filter = new ChannelProcessingFilter();
118: filter
119: .setChannelDecisionManager(new MockChannelDecisionManager(
120: false, "SUPPORTS_MOCK_ONLY"));
121:
122: ConfigAttributeDefinition attr = new ConfigAttributeDefinition();
123: attr
124: .addConfigAttribute(new SecurityConfig(
125: "SUPPORTS_MOCK_ONLY"));
126: attr
127: .addConfigAttribute(new SecurityConfig(
128: "INVALID_ATTRIBUTE"));
129:
130: MockFilterInvocationDefinitionMap fids = new MockFilterInvocationDefinitionMap(
131: "/path", attr, true);
132:
133: filter.setFilterInvocationDefinitionSource(fids);
134:
135: try {
136: filter.afterPropertiesSet();
137: fail("Should have thrown IllegalArgumentException");
138: } catch (IllegalArgumentException expected) {
139: assertTrue(expected.getMessage().startsWith(
140: "Unsupported configuration attributes:"));
141: }
142: }
143:
144: public void testDoFilterWhenManagerDoesCommitResponse()
145: throws Exception {
146: ChannelProcessingFilter filter = new ChannelProcessingFilter();
147: filter
148: .setChannelDecisionManager(new MockChannelDecisionManager(
149: true, "SOME_ATTRIBUTE"));
150:
151: ConfigAttributeDefinition attr = new ConfigAttributeDefinition();
152: attr.addConfigAttribute(new SecurityConfig("SOME_ATTRIBUTE"));
153:
154: MockFilterInvocationDefinitionMap fids = new MockFilterInvocationDefinitionMap(
155: "/path", attr, true);
156:
157: filter.setFilterInvocationDefinitionSource(fids);
158:
159: MockHttpServletRequest request = new MockHttpServletRequest();
160: request.setQueryString("info=now");
161: request.setServletPath("/path");
162:
163: MockHttpServletResponse response = new MockHttpServletResponse();
164: MockFilterChain chain = new MockFilterChain(false);
165:
166: filter.doFilter(request, response, chain);
167: assertTrue(true);
168: }
169:
170: public void testDoFilterWhenManagerDoesNotCommitResponse()
171: throws Exception {
172: ChannelProcessingFilter filter = new ChannelProcessingFilter();
173: filter
174: .setChannelDecisionManager(new MockChannelDecisionManager(
175: false, "SOME_ATTRIBUTE"));
176:
177: ConfigAttributeDefinition attr = new ConfigAttributeDefinition();
178: attr.addConfigAttribute(new SecurityConfig("SOME_ATTRIBUTE"));
179:
180: MockFilterInvocationDefinitionMap fids = new MockFilterInvocationDefinitionMap(
181: "/path", attr, true);
182:
183: filter.setFilterInvocationDefinitionSource(fids);
184:
185: MockHttpServletRequest request = new MockHttpServletRequest();
186: request.setQueryString("info=now");
187: request.setServletPath("/path");
188:
189: MockHttpServletResponse response = new MockHttpServletResponse();
190: MockFilterChain chain = new MockFilterChain(true);
191:
192: filter.doFilter(request, response, chain);
193: assertTrue(true);
194: }
195:
196: public void testDoFilterWhenNullConfigAttributeReturned()
197: throws Exception {
198: ChannelProcessingFilter filter = new ChannelProcessingFilter();
199: filter
200: .setChannelDecisionManager(new MockChannelDecisionManager(
201: false, "NOT_USED"));
202:
203: ConfigAttributeDefinition attr = new ConfigAttributeDefinition();
204: attr.addConfigAttribute(new SecurityConfig("NOT_USED"));
205:
206: MockFilterInvocationDefinitionMap fids = new MockFilterInvocationDefinitionMap(
207: "/path", attr, true);
208:
209: filter.setFilterInvocationDefinitionSource(fids);
210:
211: MockHttpServletRequest request = new MockHttpServletRequest();
212: request.setQueryString("info=now");
213: request.setServletPath("/PATH_NOT_MATCHING_CONFIG_ATTRIBUTE");
214:
215: MockHttpServletResponse response = new MockHttpServletResponse();
216: MockFilterChain chain = new MockFilterChain(true);
217:
218: filter.doFilter(request, response, chain);
219: assertTrue(true);
220: }
221:
222: public void testDoFilterWithNonHttpServletRequestDetected()
223: throws Exception {
224: ChannelProcessingFilter filter = new ChannelProcessingFilter();
225:
226: try {
227: filter.doFilter(null, new MockHttpServletResponse(),
228: new MockFilterChain());
229: fail("Should have thrown ServletException");
230: } catch (ServletException expected) {
231: assertEquals("HttpServletRequest required", expected
232: .getMessage());
233: }
234: }
235:
236: public void testDoFilterWithNonHttpServletResponseDetected()
237: throws Exception {
238: ChannelProcessingFilter filter = new ChannelProcessingFilter();
239:
240: try {
241: filter.doFilter(new MockHttpServletRequest(null, null),
242: null, new MockFilterChain());
243: fail("Should have thrown ServletException");
244: } catch (ServletException expected) {
245: assertEquals("HttpServletResponse required", expected
246: .getMessage());
247: }
248: }
249:
250: public void testGetterSetters() throws Exception {
251: ChannelProcessingFilter filter = new ChannelProcessingFilter();
252: filter
253: .setChannelDecisionManager(new MockChannelDecisionManager(
254: false, "MOCK"));
255: assertTrue(filter.getChannelDecisionManager() != null);
256:
257: ConfigAttributeDefinition attr = new ConfigAttributeDefinition();
258: attr.addConfigAttribute(new SecurityConfig("MOCK"));
259:
260: MockFilterInvocationDefinitionMap fids = new MockFilterInvocationDefinitionMap(
261: "/path", attr, false);
262:
263: filter.setFilterInvocationDefinitionSource(fids);
264: assertTrue(filter.getFilterInvocationDefinitionSource() != null);
265:
266: filter.init(null);
267: filter.afterPropertiesSet();
268: filter.destroy();
269: }
270:
271: //~ Inner Classes ==================================================================================================
272:
273: private class MockChannelDecisionManager implements
274: ChannelDecisionManager {
275: private String supportAttribute;
276: private boolean commitAResponse;
277:
278: public MockChannelDecisionManager(boolean commitAResponse,
279: String supportAttribute) {
280: this .commitAResponse = commitAResponse;
281: this .supportAttribute = supportAttribute;
282: }
283:
284: private MockChannelDecisionManager() {
285: super ();
286: }
287:
288: public void decide(FilterInvocation invocation,
289: ConfigAttributeDefinition config) throws IOException,
290: ServletException {
291: if (commitAResponse) {
292: invocation.getHttpResponse()
293: .sendRedirect("/redirected");
294: }
295: }
296:
297: public boolean supports(ConfigAttribute attribute) {
298: if (attribute.getAttribute().equals(supportAttribute)) {
299: return true;
300: } else {
301: return false;
302: }
303: }
304: }
305:
306: private class MockFilterChain implements FilterChain {
307: private boolean expectToProceed;
308:
309: public MockFilterChain(boolean expectToProceed) {
310: this .expectToProceed = expectToProceed;
311: }
312:
313: private MockFilterChain() {
314: super ();
315: }
316:
317: public void doFilter(ServletRequest request,
318: ServletResponse response) throws IOException,
319: ServletException {
320: if (expectToProceed) {
321: assertTrue(true);
322: } else {
323: fail("Did not expect filter chain to proceed");
324: }
325: }
326: }
327:
328: private class MockFilterInvocationDefinitionMap implements
329: FilterInvocationDefinitionSource {
330: private ConfigAttributeDefinition toReturn;
331: private String servletPath;
332: private boolean provideIterator;
333:
334: public MockFilterInvocationDefinitionMap(String servletPath,
335: ConfigAttributeDefinition toReturn,
336: boolean provideIterator) {
337: this .servletPath = servletPath;
338: this .toReturn = toReturn;
339: this .provideIterator = provideIterator;
340: }
341:
342: private MockFilterInvocationDefinitionMap() {
343: super ();
344: }
345:
346: public ConfigAttributeDefinition getAttributes(Object object)
347: throws IllegalArgumentException {
348: FilterInvocation fi = (FilterInvocation) object;
349:
350: if (servletPath
351: .equals(fi.getHttpRequest().getServletPath())) {
352: return toReturn;
353: } else {
354: return null;
355: }
356: }
357:
358: public Iterator getConfigAttributeDefinitions() {
359: if (!provideIterator) {
360: return null;
361: }
362:
363: List list = new Vector();
364: list.add(toReturn);
365:
366: return list.iterator();
367: }
368:
369: public boolean supports(Class clazz) {
370: return true;
371: }
372: }
373: }
|