001: /*
002: * $Id: FilterTest.java 484717 2006-12-08 19:57:59Z mrdon $
003: *
004: * Licensed to the Apache Software Foundation (ASF) under one
005: * or more contributor license agreements. See the NOTICE file
006: * distributed with this work for additional information
007: * regarding copyright ownership. The ASF licenses this file
008: * to you under the Apache License, Version 2.0 (the
009: * "License"); you may not use this file except in compliance
010: * with the License. You may obtain a copy of the License at
011: *
012: * http://www.apache.org/licenses/LICENSE-2.0
013: *
014: * Unless required by applicable law or agreed to in writing,
015: * software distributed under the License is distributed on an
016: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017: * KIND, either express or implied. See the License for the
018: * specific language governing permissions and limitations
019: * under the License.
020: */
021: package org.apache.struts2.dispatcher;
022:
023: import java.io.IOException;
024: import java.util.HashMap;
025:
026: import javax.servlet.FilterConfig;
027: import javax.servlet.ServletContext;
028: import javax.servlet.ServletException;
029: import javax.servlet.ServletRequest;
030: import javax.servlet.ServletResponse;
031: import javax.servlet.http.HttpServletRequest;
032: import javax.servlet.http.HttpServletResponse;
033:
034: import junit.framework.TestCase;
035:
036: import org.apache.struts2.dispatcher.mapper.ActionMapper;
037: import org.apache.struts2.dispatcher.mapper.ActionMapping;
038: import org.springframework.mock.web.MockFilterConfig;
039: import org.springframework.mock.web.MockHttpServletRequest;
040: import org.springframework.mock.web.MockHttpServletResponse;
041: import org.springframework.mock.web.MockServletContext;
042:
043: import com.mockobjects.servlet.MockFilterChain;
044: import com.opensymphony.xwork2.ObjectFactory;
045: import com.opensymphony.xwork2.config.ConfigurationManager;
046: import com.opensymphony.xwork2.inject.Container;
047:
048: /**
049: *
050: * @version $Date: 2006-12-08 14:57:59 -0500 (Fri, 08 Dec 2006) $ $Id: FilterTest.java 484717 2006-12-08 19:57:59Z mrdon $
051: */
052: public class FilterTest extends TestCase {
053:
054: protected MockFilterConfig filterConfig;
055: protected MockHttpServletRequest request;
056: protected MockHttpServletResponse response;
057: protected MockFilterChain filterChain;
058: protected MockFilterChain filterChain2;
059: protected MockServletContext servletContext;
060:
061: protected InnerDispatcher _dispatcher1;
062: protected InnerDispatcher _dispatcher2;
063: protected ActionContextCleanUp cleanUp;
064: protected FilterDispatcher filterDispatcher;
065:
066: protected int cleanUpFilterCreateDispatcherCount = 0; // number of times clean up filter create a dispatcher
067: protected int filterDispatcherCreateDispatcherCount = 0; // number of times FilterDispatcher create a dispatcher
068:
069: @Override
070: protected void tearDown() throws Exception {
071: filterConfig = null;
072: request = null;
073: response = null;
074: filterChain = null;
075: filterChain2 = null;
076: servletContext = null;
077: _dispatcher1 = null;
078: _dispatcher2 = null;
079: cleanUp = null;
080: filterDispatcher = null;
081: }
082:
083: @Override
084: protected void setUp() throws Exception {
085: Dispatcher.setInstance(null);
086:
087: filterConfig = new MockFilterConfig();
088: request = new MockHttpServletRequest();
089: response = new MockHttpServletResponse();
090: servletContext = new MockServletContext();
091:
092: _dispatcher1 = new InnerDispatcher(servletContext) {
093: @Override
094: public String toString() {
095: return "dispatcher1";
096: }
097: };
098: _dispatcher2 = new InnerDispatcher(servletContext) {
099: @Override
100: public String toString() {
101: return "dispatcher2";
102: }
103: };
104: filterChain = new MockFilterChain() {
105: @Override
106: public void doFilter(ServletRequest req, ServletResponse res)
107: throws IOException, ServletException {
108: filterDispatcher.doFilter(req, res, filterChain2);
109: }
110: };
111: filterChain2 = new MockFilterChain() {
112: @Override
113: public void doFilter(ServletRequest req, ServletResponse res)
114: throws IOException, ServletException {
115: }
116: };
117:
118: cleanUp = new ActionContextCleanUp();
119:
120: filterDispatcher = new FilterDispatcher() {
121: @Override
122: protected Dispatcher createDispatcher(
123: FilterConfig filterConfig) {
124: filterDispatcherCreateDispatcherCount++;
125: return _dispatcher2;
126: }
127:
128: @Override
129: public String toString() {
130: return "filterDispatcher";
131: }
132: };
133: }
134:
135: public void testUsingFilterDispatcherOnly() throws Exception {
136: assertEquals(cleanUpFilterCreateDispatcherCount, 0);
137: assertEquals(filterDispatcherCreateDispatcherCount, 0);
138: assertFalse(_dispatcher1.init);
139: assertFalse(_dispatcher1.prepare);
140: assertFalse(_dispatcher1.wrapRequest);
141: assertFalse(_dispatcher1.service);
142: assertFalse(_dispatcher2.init);
143: assertFalse(_dispatcher2.prepare);
144: assertFalse(_dispatcher2.wrapRequest);
145: assertFalse(_dispatcher2.service);
146:
147: filterDispatcher.init(filterConfig);
148: FilterDispatcher.setActionMapper(new FilterTest.InnerMapper());
149: filterDispatcher.doFilter(request, response, filterChain2);
150: filterDispatcher.destroy();
151:
152: // we are using FilterDispatcher only, so cleanUp filter's Dispatcher should not be created.
153: assertEquals(cleanUpFilterCreateDispatcherCount, 0);
154: assertEquals(filterDispatcherCreateDispatcherCount, 1);
155: assertFalse(_dispatcher1.init);
156: assertFalse(_dispatcher1.prepare);
157: assertFalse(_dispatcher1.wrapRequest);
158: assertFalse(_dispatcher1.service);
159: assertTrue(_dispatcher2.init);
160: assertTrue(_dispatcher2.prepare);
161: assertTrue(_dispatcher2.wrapRequest);
162: assertTrue(_dispatcher2.service);
163: assertTrue(Dispatcher.getInstance() == null);
164: }
165:
166: public void testUsingFilterDispatcherOnly_Multiple()
167: throws Exception {
168:
169: filterDispatcher.setActionMapper(new FilterTest.InnerMapper());
170:
171: assertEquals(cleanUpFilterCreateDispatcherCount, 0);
172: assertEquals(filterDispatcherCreateDispatcherCount, 0);
173: assertFalse(_dispatcher1.prepare);
174: assertFalse(_dispatcher1.wrapRequest);
175: assertFalse(_dispatcher1.service);
176: assertFalse(_dispatcher1.cleanUp);
177: assertFalse(_dispatcher2.prepare);
178: assertFalse(_dispatcher2.wrapRequest);
179: assertFalse(_dispatcher2.service);
180: assertFalse(_dispatcher2.cleanUp);
181:
182: filterDispatcher.init(filterConfig);
183: FilterDispatcher.setActionMapper(new FilterTest.InnerMapper());
184: filterDispatcher.doFilter(request, response, filterChain2);
185: filterDispatcher.doFilter(request, response, filterChain2);
186: filterDispatcher.destroy();
187:
188: assertEquals(cleanUpFilterCreateDispatcherCount, 0);
189: // We should create dispatcher once, although filter.doFilter(...) is called many times.
190: assertEquals(filterDispatcherCreateDispatcherCount, 1);
191: assertFalse(_dispatcher1.prepare);
192: assertFalse(_dispatcher1.wrapRequest);
193: assertFalse(_dispatcher1.service);
194: assertFalse(_dispatcher1.cleanUp);
195: assertTrue(_dispatcher2.prepare);
196: assertTrue(_dispatcher2.wrapRequest);
197: assertTrue(_dispatcher2.service);
198: assertTrue(_dispatcher2.cleanUp);
199: assertTrue(Dispatcher.getInstance() == null);
200:
201: }
202:
203: /*public void testUsingCleanUpAndFilterDispatcher() throws Exception {
204: ObjectFactory oldObjecFactory = ObjectFactory.getObjectFactory();
205: try {
206: ObjectFactory.setObjectFactory(new InnerObjectFactory());
207: filterDispatcher.setActionMapper(new FilterTest.InnerMapper());
208:
209: assertEquals(cleanUpFilterCreateDispatcherCount, 0);
210: assertEquals(filterDispatcherCreateDispatcherCount, 0);
211: assertFalse(_dispatcher1.prepare);
212: assertFalse(_dispatcher1.wrapRequest);
213: assertFalse(_dispatcher1.service);
214: assertFalse(_dispatcher2.prepare);
215: assertFalse(_dispatcher2.wrapRequest);
216: assertFalse(_dispatcher2.service);
217:
218: cleanUp.init(filterConfig);
219: filterDispatcher.init(filterConfig);
220: cleanUp.doFilter(request, response, filterChain);
221: filterDispatcher.destroy();
222: cleanUp.destroy();
223:
224: assertEquals(1, cleanUpFilterCreateDispatcherCount);
225: assertEquals(1, filterDispatcherCreateDispatcherCount);
226: assertTrue(_dispatcher1.prepare);
227: assertTrue(_dispatcher1.wrapRequest);
228: assertTrue(_dispatcher1.service);
229: assertFalse(_dispatcher2.prepare);
230: assertFalse(_dispatcher2.wrapRequest);
231: assertFalse(_dispatcher2.service);
232: assertTrue(Dispatcher.getInstance() == null);
233: }
234: finally {
235: ObjectFactory.setObjectFactory(oldObjecFactory);
236: }
237: }
238:
239:
240: public void testUsingCleanUpAndFilterDispatcher_Multiple() throws Exception {
241: ObjectFactory oldObjecFactory = ObjectFactory.getObjectFactory();
242: try {
243: ObjectFactory.setObjectFactory(new InnerObjectFactory());
244: filterDispatcher.setActionMapper(new FilterTest.InnerMapper());
245:
246: assertEquals(cleanUpFilterCreateDispatcherCount, 0);
247: assertEquals(filterDispatcherCreateDispatcherCount, 0);
248: assertFalse(_dispatcher1.prepare);
249: assertFalse(_dispatcher1.wrapRequest);
250: assertFalse(_dispatcher1.service);
251: assertFalse(_dispatcher2.prepare);
252: assertFalse(_dispatcher2.wrapRequest);
253: assertFalse(_dispatcher2.service);
254:
255: cleanUp.init(filterConfig);
256: filterDispatcher.init(filterConfig);
257: cleanUp.doFilter(request, response, filterChain);
258: cleanUp.doFilter(request, response, filterChain);
259: filterDispatcher.destroy();
260: cleanUp.destroy();
261:
262: assertEquals(cleanUpFilterCreateDispatcherCount, 1);
263: assertEquals(filterDispatcherCreateDispatcherCount, 1);
264: assertTrue(_dispatcher1.prepare);
265: assertTrue(_dispatcher1.wrapRequest);
266: assertTrue(_dispatcher1.service);
267: assertFalse(_dispatcher2.prepare);
268: assertFalse(_dispatcher2.wrapRequest);
269: assertFalse(_dispatcher2.service);
270: assertTrue(Dispatcher.getInstance() == null);
271: }
272: finally {
273: ObjectFactory.setObjectFactory(oldObjecFactory);
274: }
275: }
276: */
277:
278: class InnerDispatcher extends Dispatcher {
279: public boolean init = false;
280: public boolean prepare = false;
281: public boolean wrapRequest = false;
282: public boolean service = false;
283: public boolean cleanUp = false;
284:
285: public InnerDispatcher(ServletContext servletContext) {
286: super (servletContext, new HashMap<String, String>());
287: }
288:
289: @Override
290: public void init() {
291: init = true;
292: }
293:
294: @Override
295: public Container getContainer() {
296: return null;
297: }
298:
299: @Override
300: public void prepare(HttpServletRequest request,
301: HttpServletResponse response) {
302: prepare = true;
303: }
304:
305: @Override
306: public HttpServletRequest wrapRequest(
307: HttpServletRequest request,
308: ServletContext servletContext) throws IOException {
309: wrapRequest = true;
310: return request;
311: }
312:
313: @Override
314: public void serviceAction(HttpServletRequest request,
315: HttpServletResponse response, ServletContext context,
316: ActionMapping mapping) throws ServletException {
317: service = true;
318: }
319:
320: @Override
321: public void cleanup() {
322: cleanUp = true;
323: }
324: }
325:
326: class NullInnerMapper implements ActionMapper {
327: public ActionMapping getMapping(HttpServletRequest request,
328: ConfigurationManager configManager) {
329: return null;
330: }
331:
332: public String getUriFromActionMapping(ActionMapping mapping) {
333: return null;
334: }
335: }
336:
337: public static class InnerMapper implements ActionMapper {
338:
339: public InnerMapper() {
340: }
341:
342: public ActionMapping getMapping(HttpServletRequest request,
343: ConfigurationManager configManager) {
344: return new ActionMapping();
345: }
346:
347: public String getUriFromActionMapping(ActionMapping mapping) {
348: return "";
349: }
350: }
351:
352: class InnerObjectFactory extends ObjectFactory {
353: public InnerObjectFactory() {
354: super();
355: }
356: }
357: }
|