View Javadoc

1   /*
2    * $Id: FilterDispatcherTest.java 708334 2008-10-27 21:46:04Z rgielen $
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  package org.apache.struts2.dispatcher;
22  
23  import java.io.IOException;
24  import java.io.InputStream;
25  import java.util.HashMap;
26  import java.util.Map;
27  import java.util.List;
28  import java.net.URL;
29  
30  import javax.servlet.FilterConfig;
31  import javax.servlet.ServletContext;
32  import javax.servlet.ServletException;
33  import javax.servlet.http.HttpServletRequest;
34  import javax.servlet.http.HttpServletResponse;
35  
36  import org.apache.struts2.StrutsConstants;
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.apache.struts2.util.ObjectFactoryDestroyable;
41  import org.springframework.mock.web.MockFilterConfig;
42  import org.springframework.mock.web.MockHttpServletRequest;
43  import org.springframework.mock.web.MockHttpServletResponse;
44  import org.springframework.mock.web.MockServletContext;
45  
46  import com.mockobjects.servlet.MockFilterChain;
47  import com.opensymphony.xwork2.ObjectFactory;
48  import com.opensymphony.xwork2.config.ConfigurationManager;
49  import com.opensymphony.xwork2.config.impl.DefaultConfiguration;
50  import com.opensymphony.xwork2.inject.Container;
51  import com.opensymphony.xwork2.inject.ContainerBuilder;
52  import com.opensymphony.xwork2.inject.Context;
53  import com.opensymphony.xwork2.inject.Factory;
54  
55  /***
56   * FilterDispatcher TestCase.
57   *
58   * @version $Date: 2008-10-27 22:46:04 +0100 (Mo, 27. Okt 2008) $ $Id: FilterDispatcherTest.java 708334 2008-10-27 21:46:04Z rgielen $
59   */
60  public class FilterDispatcherTest extends StrutsTestCase {
61  
62  
63      public void testParsePackages() throws Exception {
64  
65          FilterDispatcher filterDispatcher = new FilterDispatcher();
66          String[] result1 = filterDispatcher.parse("foo.bar.package1 foo.bar.package2 foo.bar.package3");
67          String[] result2 = filterDispatcher.parse("foo.bar.package1\tfoo.bar.package2\tfoo.bar.package3");
68          String[] result3 = filterDispatcher.parse("foo.bar.package1,foo.bar.package2,foo.bar.package3");
69          String[] result4 = filterDispatcher.parse("foo.bar.package1    foo.bar.package2  \t foo.bar.package3   , foo.bar.package4");
70  
71          assertEquals(result1[0], "foo/bar/package1/");
72          assertEquals(result1[1], "foo/bar/package2/");
73          assertEquals(result1[2], "foo/bar/package3/");
74  
75          assertEquals(result2[0], "foo/bar/package1/");
76          assertEquals(result2[1], "foo/bar/package2/");
77          assertEquals(result2[2], "foo/bar/package3/");
78  
79          assertEquals(result3[0], "foo/bar/package1/");
80          assertEquals(result3[1], "foo/bar/package2/");
81          assertEquals(result3[2], "foo/bar/package3/");
82  
83          assertEquals(result4[0], "foo/bar/package1/");
84          assertEquals(result4[1], "foo/bar/package2/");
85          assertEquals(result4[2], "foo/bar/package3/");
86          assertEquals(result4[3], "foo/bar/package4/");
87      }
88  
89      public void testObjectFactoryDestroy() throws Exception {
90  
91          final InnerDestroyableObjectFactory destroyedObjectFactory = new InnerDestroyableObjectFactory();
92          FilterDispatcher filterDispatcher = new FilterDispatcher() {
93              @Override
94              protected Dispatcher createDispatcher(FilterConfig cfg) {
95                  return new Dispatcher(cfg.getServletContext(), new HashMap()) {
96                      Container cont = new ContainerBuilder()
97                          .factory(ObjectFactory.class, new Factory() {
98                              public Object create(Context context) throws Exception { return destroyedObjectFactory; }
99                          })
100                         .create(false);
101                     
102                     @Override
103                     public Container getContainer() {
104                         return cont;
105                     }
106                 };
107             }
108         };
109         filterDispatcher.init(new MockFilterConfig((ServletContext) null));
110         
111         assertFalse(destroyedObjectFactory.destroyed);
112         filterDispatcher.destroy();
113         assertTrue(destroyedObjectFactory.destroyed);
114     }
115 
116     public void testIfActionMapperIsNullDontServiceAction() throws Exception {
117         MockServletContext servletContext = new MockServletContext();
118         MockFilterConfig filterConfig = new MockFilterConfig(servletContext);
119         MockHttpServletRequest req = new MockHttpServletRequest(servletContext);
120         MockHttpServletResponse res = new MockHttpServletResponse();
121         MockFilterChain chain = new MockFilterChain();
122         final NoOpDispatcher _dispatcher = new NoOpDispatcher(servletContext);
123         ConfigurationManager confManager = new ConfigurationManager();
124         confManager.setConfiguration(new DefaultConfiguration());
125         _dispatcher.setConfigurationManager(confManager);
126         Dispatcher.setInstance(_dispatcher);
127 
128         
129 
130 
131         ObjectFactory.setObjectFactory(new InnerObjectFactory());
132 
133         FilterDispatcher filter = new FilterDispatcher() {
134             protected Dispatcher createDispatcher() {
135                 return _dispatcher;
136             }
137         };
138         filter.setActionMapper(null);
139         filter.init(filterConfig);
140         filter.doFilter(req, res, chain);
141 
142         assertFalse(_dispatcher.serviceRequest);
143     }
144 
145     public void testCharacterEncodingSetBeforeRequestWrappingAndActionService() throws Exception {
146         MockServletContext servletContext = new MockServletContext();
147         MockFilterConfig filterConfig = new MockFilterConfig(servletContext);
148         MockHttpServletRequest req = new MockHttpServletRequest(servletContext);
149         MockHttpServletResponse res = new MockHttpServletResponse();
150         MockFilterChain chain = new MockFilterChain();
151         final InnerDispatcher _dispatcher = new InnerDispatcher(servletContext);
152         Dispatcher.setInstance(null);
153 
154         DefaultConfiguration conf = new DefaultConfiguration() {
155         	@Override
156         	public Container getContainer() {
157         		return new ContainerBuilder().create(false);
158         	}
159         };
160        
161         ConfigurationManager confManager = new ConfigurationManager();
162         confManager.setConfiguration(conf);
163         _dispatcher.setConfigurationManager(confManager);
164 
165 
166         ObjectFactory.setObjectFactory(new InnerObjectFactory());
167 
168         _dispatcher.setDefaultEncoding("UTF-16_DUMMY");
169 
170         FilterDispatcher filter = new FilterDispatcher() {
171             protected Dispatcher createDispatcher(FilterConfig filterConfig) {
172                 return _dispatcher;
173             }
174         };
175         filter.setActionMapper(new InnerActionMapper());
176         filter.init(filterConfig);
177         filter.doFilter(req, res, chain);
178 
179         assertTrue(_dispatcher.wrappedRequest);
180         assertTrue(_dispatcher.serviceRequest);
181     }
182 
183     public void testFindAndCheckResourcesWithDojoJs() throws Exception  {
184         FilterDispatcher filterDispatcher = new FilterDispatcher();
185         filterDispatcher.pathPrefixes = filterDispatcher.parse(FilterDispatcher.DEFAULT_STATIC_PACKAGES);
186         List<URL> result = filterDispatcher.findAndCheckResources("/struts/dojo/dojo.js");
187         assertTrue(result.size()>=1);
188         for (URL url : result) {
189             try {
190                 InputStream is = url.openStream();
191                 is.close();
192             } catch (IOException e) {
193                 fail("Resource could not be opened");
194             }
195 
196         }
197     }
198 
199     public void testFindAndCheckResourcesWithValidationClientJs() throws Exception  {
200         FilterDispatcher filterDispatcher = new FilterDispatcher();
201         filterDispatcher.pathPrefixes = filterDispatcher.parse(FilterDispatcher.DEFAULT_STATIC_PACKAGES);
202         List<URL> result = filterDispatcher.findAndCheckResources("/struts/validationClient.js");
203         assertTrue(result.size()>=1);
204         for (URL url : result) {
205             try {
206                 InputStream is = url.openStream();
207                 is.close();
208             } catch (IOException e) {
209                 fail("Resource could not be opened");
210             }
211 
212         }
213     }
214 
215     // === inner class ========
216     public static class InnerObjectFactory extends ObjectFactory {
217 
218     }
219 
220     public static class NoOpDispatcher extends Dispatcher {
221         protected boolean wrappedRequest = false;
222         protected boolean serviceRequest = false;
223 
224         public NoOpDispatcher(ServletContext servletContext) {
225             super(servletContext, new HashMap());
226         }
227 
228         @Override
229         public HttpServletRequest wrapRequest(HttpServletRequest request, ServletContext servletContext) throws IOException {
230             wrappedRequest = true;
231             return request;
232         }
233 
234         public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context, ActionMapping mapping) throws ServletException {
235             serviceRequest = true;
236         }
237     }
238 
239     public static class InnerDispatcher extends Dispatcher {
240 
241         protected boolean wrappedRequest = false;
242         protected boolean serviceRequest = false;
243 
244         public InnerDispatcher(ServletContext servletContext) {
245             super(servletContext, new HashMap());
246         }
247 
248         @Override
249         public HttpServletRequest wrapRequest(HttpServletRequest request, ServletContext servletContext) throws IOException {
250             wrappedRequest = true;
251             // if we set the chracter encoding AFTER we do wrap request, we will get
252             // a failing test
253             assertNotNull(request.getCharacterEncoding());
254             assertEquals(request.getCharacterEncoding(), "UTF-16_DUMMY");
255 
256             return request;
257         }
258 
259         public void serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context, ActionMapping mapping) throws ServletException {
260             serviceRequest = true;
261             // if we set the chracter encoding AFTER we do wrap request, we will get
262             // a failing test
263             assertNotNull(request.getCharacterEncoding());
264             assertEquals(request.getCharacterEncoding(), "UTF-16_DUMMY");
265         }
266     }
267 
268     public static class InnerActionMapper implements ActionMapper {
269 
270         public ActionMapping getMapping(HttpServletRequest request, ConfigurationManager config) {
271             return new ActionMapping();
272         }
273 
274         public String getUriFromActionMapping(ActionMapping mapping) {
275             return null;
276         }
277     }
278 
279     public static class NullActionMapper implements ActionMapper {
280         public ActionMapping getMapping(HttpServletRequest request, ConfigurationManager config) {
281             return null;
282         }
283 
284         public String getUriFromActionMapping(ActionMapping mapping) {
285             return null;
286         }
287     }
288 
289 
290     public static class InnerDestroyableObjectFactory extends ObjectFactory implements ObjectFactoryDestroyable {
291         public boolean destroyed = false;
292 
293         public void destroy() {
294             destroyed = true;
295         }
296     }
297 
298 }