View Javadoc

1   /*
2    * $Id: FilterTest.java 651946 2008-04-27 13:41:38Z apetrelli $
3    *
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  package org.apache.struts2.dispatcher;
23  
24  import java.io.IOException;
25  import java.util.HashMap;
26  
27  import javax.servlet.FilterConfig;
28  import javax.servlet.ServletContext;
29  import javax.servlet.ServletException;
30  import javax.servlet.ServletRequest;
31  import javax.servlet.ServletResponse;
32  import javax.servlet.http.HttpServletRequest;
33  import javax.servlet.http.HttpServletResponse;
34  
35  import junit.framework.TestCase;
36  
37  import org.apache.struts2.StrutsTestCase;
38  import org.apache.struts2.dispatcher.mapper.ActionMapper;
39  import org.apache.struts2.dispatcher.mapper.ActionMapping;
40  import org.springframework.mock.web.MockFilterConfig;
41  import org.springframework.mock.web.MockHttpServletRequest;
42  import org.springframework.mock.web.MockHttpServletResponse;
43  import org.springframework.mock.web.MockServletContext;
44  
45  import com.mockobjects.servlet.MockFilterChain;
46  import com.opensymphony.xwork2.ObjectFactory;
47  import com.opensymphony.xwork2.config.ConfigurationManager;
48  import com.opensymphony.xwork2.inject.Container;
49  
50  
51  /***
52   *
53   * @version $Date: 2008-04-27 08:41:38 -0500 (Sun, 27 Apr 2008) $ $Id: FilterTest.java 651946 2008-04-27 13:41:38Z apetrelli $
54   */
55  public class FilterTest extends StrutsTestCase {
56  
57      protected MockFilterConfig filterConfig;
58      protected MockHttpServletRequest request;
59      protected MockHttpServletResponse response;
60      protected MockFilterChain filterChain;
61      protected MockFilterChain filterChain2;
62      protected MockServletContext servletContext;
63  
64      protected InnerDispatcher _dispatcher1;
65      protected InnerDispatcher _dispatcher2;
66      protected ActionContextCleanUp cleanUp;
67      protected FilterDispatcher filterDispatcher;
68  
69      protected int cleanUpFilterCreateDispatcherCount = 0; // number of times clean up filter create a dispatcher
70      protected int filterDispatcherCreateDispatcherCount = 0; // number of times FilterDispatcher create a dispatcher
71  
72  
73      @Override
74      protected void tearDown() throws Exception {
75          super.tearDown();
76          filterConfig = null;
77          request = null;
78          response = null;
79          filterChain = null;
80          filterChain2 = null;
81          servletContext = null;
82          _dispatcher1 = null;
83          _dispatcher2 = null;
84          cleanUp = null;
85          filterDispatcher = null;
86      }
87  
88      @Override
89      protected void setUp() throws Exception {
90          super.setUp();
91          Dispatcher.setInstance(null);
92  
93          filterConfig = new MockFilterConfig();
94          request = new MockHttpServletRequest();
95          response = new MockHttpServletResponse();
96          servletContext = new MockServletContext();
97  
98          _dispatcher1 = new InnerDispatcher(servletContext){
99              @Override
100             public String toString() {
101                 return "dispatcher1";
102             }
103         };
104         _dispatcher2 = new InnerDispatcher(servletContext){
105             @Override
106             public String toString() {
107                 return "dispatcher2";
108             }
109         };
110         filterChain = new MockFilterChain() {
111             @Override
112             public void doFilter(ServletRequest req, ServletResponse res) throws IOException, ServletException {
113                 filterDispatcher.doFilter(req, res, filterChain2);
114             }
115         };
116         filterChain2 = new MockFilterChain() {
117             @Override
118             public void doFilter(ServletRequest req, ServletResponse res) throws IOException, ServletException {
119             }
120         };
121 
122 
123         cleanUp = new ActionContextCleanUp();
124 
125         filterDispatcher = new FilterDispatcher() {
126             @Override
127             protected Dispatcher createDispatcher(FilterConfig filterConfig) {
128                 filterDispatcherCreateDispatcherCount++;
129                 return _dispatcher2;
130             }
131             
132             @Override
133             public String toString() {
134                 return "filterDispatcher";
135             }
136         };
137     }
138 
139     public void testUsingFilterDispatcherOnly() throws Exception {
140         assertEquals(cleanUpFilterCreateDispatcherCount, 0);
141         assertEquals(filterDispatcherCreateDispatcherCount, 0);
142         assertFalse(_dispatcher1.init);
143         assertFalse(_dispatcher1.prepare);
144         assertFalse(_dispatcher1.wrapRequest);
145         assertFalse(_dispatcher1.service);
146         assertFalse(_dispatcher2.init);
147         assertFalse(_dispatcher2.prepare);
148         assertFalse(_dispatcher2.wrapRequest);
149         assertFalse(_dispatcher2.service);
150 
151         filterDispatcher.init(filterConfig);
152         filterDispatcher.setActionMapper(new FilterTest.InnerMapper());
153         filterDispatcher.doFilter(request, response, filterChain2);
154         filterDispatcher.destroy();
155 
156         // we are using FilterDispatcher only, so cleanUp filter's Dispatcher should not be created.
157         assertEquals(cleanUpFilterCreateDispatcherCount, 0);
158         assertEquals(filterDispatcherCreateDispatcherCount, 1);
159         assertFalse(_dispatcher1.init);
160         assertFalse(_dispatcher1.prepare);
161         assertFalse(_dispatcher1.wrapRequest);
162         assertFalse(_dispatcher1.service);
163         assertTrue(_dispatcher2.init);
164         assertTrue(_dispatcher2.prepare);
165         assertTrue(_dispatcher2.wrapRequest);
166         assertTrue(_dispatcher2.service);
167         assertTrue(Dispatcher.getInstance() == null);
168     }
169 
170 
171     public void testUsingFilterDispatcherOnly_Multiple() throws Exception {
172         
173         filterDispatcher.setActionMapper(new FilterTest.InnerMapper());
174 
175         assertEquals(cleanUpFilterCreateDispatcherCount, 0);
176         assertEquals(filterDispatcherCreateDispatcherCount, 0);
177         assertFalse(_dispatcher1.prepare);
178         assertFalse(_dispatcher1.wrapRequest);
179         assertFalse(_dispatcher1.service);
180         assertFalse(_dispatcher1.cleanUp);
181         assertFalse(_dispatcher2.prepare);
182         assertFalse(_dispatcher2.wrapRequest);
183         assertFalse(_dispatcher2.service);
184         assertFalse(_dispatcher2.cleanUp);
185 
186         filterDispatcher.init(filterConfig);
187         filterDispatcher.setActionMapper(new FilterTest.InnerMapper());
188         filterDispatcher.doFilter(request, response, filterChain2);
189         filterDispatcher.doFilter(request, response, filterChain2);
190         filterDispatcher.destroy();
191 
192         assertEquals(cleanUpFilterCreateDispatcherCount, 0);
193         // We should create dispatcher once, although filter.doFilter(...) is called  many times.
194         assertEquals(filterDispatcherCreateDispatcherCount, 1);
195         assertFalse(_dispatcher1.prepare);
196         assertFalse(_dispatcher1.wrapRequest);
197         assertFalse(_dispatcher1.service);
198         assertFalse(_dispatcher1.cleanUp);
199         assertTrue(_dispatcher2.prepare);
200         assertTrue(_dispatcher2.wrapRequest);
201         assertTrue(_dispatcher2.service);
202         assertTrue(_dispatcher2.cleanUp);
203         assertTrue(Dispatcher.getInstance() == null);
204         
205     }
206 
207     
208 
209     /*public void testUsingCleanUpAndFilterDispatcher() throws Exception {
210         ObjectFactory oldObjecFactory = ObjectFactory.getObjectFactory();
211         try {
212             ObjectFactory.setObjectFactory(new InnerObjectFactory());
213             filterDispatcher.setActionMapper(new FilterTest.InnerMapper());
214 
215             assertEquals(cleanUpFilterCreateDispatcherCount, 0);
216             assertEquals(filterDispatcherCreateDispatcherCount, 0);
217             assertFalse(_dispatcher1.prepare);
218             assertFalse(_dispatcher1.wrapRequest);
219             assertFalse(_dispatcher1.service);
220             assertFalse(_dispatcher2.prepare);
221             assertFalse(_dispatcher2.wrapRequest);
222             assertFalse(_dispatcher2.service);
223 
224             cleanUp.init(filterConfig);
225             filterDispatcher.init(filterConfig);
226             cleanUp.doFilter(request, response, filterChain);
227             filterDispatcher.destroy();
228             cleanUp.destroy();
229 
230             assertEquals(1, cleanUpFilterCreateDispatcherCount);
231             assertEquals(1, filterDispatcherCreateDispatcherCount);
232             assertTrue(_dispatcher1.prepare);
233             assertTrue(_dispatcher1.wrapRequest);
234             assertTrue(_dispatcher1.service);
235             assertFalse(_dispatcher2.prepare);
236             assertFalse(_dispatcher2.wrapRequest);
237             assertFalse(_dispatcher2.service);
238             assertTrue(Dispatcher.getInstance() == null);
239         }
240         finally {
241             ObjectFactory.setObjectFactory(oldObjecFactory);
242         }
243     }
244 
245 
246     public void testUsingCleanUpAndFilterDispatcher_Multiple() throws Exception {
247         ObjectFactory oldObjecFactory = ObjectFactory.getObjectFactory();
248         try {
249             ObjectFactory.setObjectFactory(new InnerObjectFactory());
250             filterDispatcher.setActionMapper(new FilterTest.InnerMapper());
251 
252             assertEquals(cleanUpFilterCreateDispatcherCount, 0);
253             assertEquals(filterDispatcherCreateDispatcherCount, 0);
254             assertFalse(_dispatcher1.prepare);
255             assertFalse(_dispatcher1.wrapRequest);
256             assertFalse(_dispatcher1.service);
257             assertFalse(_dispatcher2.prepare);
258             assertFalse(_dispatcher2.wrapRequest);
259             assertFalse(_dispatcher2.service);
260 
261             cleanUp.init(filterConfig);
262             filterDispatcher.init(filterConfig);
263             cleanUp.doFilter(request, response, filterChain);
264             cleanUp.doFilter(request, response, filterChain);
265             filterDispatcher.destroy();
266             cleanUp.destroy();
267 
268             assertEquals(cleanUpFilterCreateDispatcherCount, 1);
269             assertEquals(filterDispatcherCreateDispatcherCount, 1);
270             assertTrue(_dispatcher1.prepare);
271             assertTrue(_dispatcher1.wrapRequest);
272             assertTrue(_dispatcher1.service);
273             assertFalse(_dispatcher2.prepare);
274             assertFalse(_dispatcher2.wrapRequest);
275             assertFalse(_dispatcher2.service);
276             assertTrue(Dispatcher.getInstance() == null);
277         }
278         finally {
279             ObjectFactory.setObjectFactory(oldObjecFactory);
280         }
281     }
282     */
283 
284 
285     class InnerDispatcher extends Dispatcher {
286     	public boolean init = false;
287         public boolean prepare = false;
288         public boolean wrapRequest = false;
289         public boolean service = false;
290         public boolean cleanUp = false;
291 
292         public InnerDispatcher(ServletContext servletContext) {
293             super(servletContext, new HashMap<String, String>());
294         }
295         
296         @Override
297         public void init() {
298         	init= true;
299         }
300         
301         @Override 
302         public Container getContainer() {
303             return container;
304         }
305 
306         @Override
307         public void prepare(HttpServletRequest request, HttpServletResponse response) {
308             prepare = true;
309         }
310 
311         @Override
312         public HttpServletRequest wrapRequest(HttpServletRequest request, ServletContext servletContext) throws IOException {
313             wrapRequest = true;
314             return request;
315         }
316 
317         @Override
318         public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context, ActionMapping mapping) throws ServletException {
319             service = true;
320         }
321         
322         @Override
323         public void cleanup() {
324         	cleanUp = true;
325         }
326     }
327 
328     class NullInnerMapper implements ActionMapper {
329         public ActionMapping getMapping(HttpServletRequest request, ConfigurationManager configManager) {
330             return null;
331         }
332 
333         public ActionMapping getMappingFromActionName(String actionName) {
334             return null;  //To change body of implemented methods use File | Settings | File Templates.
335         }
336 
337         public String getUriFromActionMapping(ActionMapping mapping) {
338             return null;
339         }
340     }
341 
342     public static class InnerMapper implements ActionMapper {
343 
344         public InnerMapper() {}
345 
346         public ActionMapping getMapping(HttpServletRequest request, ConfigurationManager configManager) {
347             return new ActionMapping();
348         }
349 
350         public ActionMapping getMappingFromActionName(String actionName) {
351             return null;  //To change body of implemented methods use File | Settings | File Templates.
352         }
353 
354         public String getUriFromActionMapping(ActionMapping mapping) {
355             return "";
356         }
357     }
358 
359     class InnerObjectFactory extends ObjectFactory {
360         public InnerObjectFactory() {
361             super();
362         }
363     }
364 }
365