View Javadoc

1   /*
2    * $Id: DefaultActionMapperTest.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.mapper;
23  
24  import java.util.Arrays;
25  import java.util.HashMap;
26  import java.util.Map;
27  
28  import org.apache.struts2.ServletActionContext;
29  import org.apache.struts2.StrutsTestCase;
30  import org.apache.struts2.dispatcher.ServletRedirectResult;
31  import org.apache.struts2.dispatcher.StrutsResultSupport;
32  import org.apache.struts2.views.jsp.StrutsMockHttpServletRequest;
33  import org.apache.struts2.views.jsp.StrutsMockHttpServletResponse;
34  
35  import com.mockobjects.dynamic.Mock;
36  import com.mockobjects.servlet.MockHttpServletRequest;
37  import com.opensymphony.xwork2.ActionContext;
38  import com.opensymphony.xwork2.ActionInvocation;
39  import com.opensymphony.xwork2.Result;
40  import com.opensymphony.xwork2.config.Configuration;
41  import com.opensymphony.xwork2.config.ConfigurationManager;
42  import com.opensymphony.xwork2.config.entities.PackageConfig;
43  import com.opensymphony.xwork2.config.impl.DefaultConfiguration;
44  
45  /***
46   * DefaultActionMapper test case.
47   *
48   */
49  public class DefaultActionMapperTest extends StrutsTestCase {
50  
51      private MockHttpServletRequest req;
52      private ConfigurationManager configManager;
53      private Configuration config;
54  
55      protected void setUp() throws Exception {
56          super.setUp();
57          req = new MockHttpServletRequest();
58          req.setupGetParameterMap(new HashMap());
59          req.setupGetContextPath("/my/namespace");
60  
61          config = new DefaultConfiguration();
62          PackageConfig pkg = new PackageConfig.Builder("myns")
63              .namespace("/my/namespace").build();
64          PackageConfig pkg2 = new PackageConfig.Builder("my").namespace("/my").build();
65          config.addPackageConfig("mvns", pkg);
66          config.addPackageConfig("my", pkg2);
67          configManager = new ConfigurationManager() {
68              public Configuration getConfiguration() {
69                  return config;
70              }
71          };
72      }
73  
74      public void testGetMapping() throws Exception {
75          req.setupGetRequestURI("/my/namespace/actionName.action");
76          req.setupGetServletPath("/my/namespace/actionName.action");
77          req.setupGetAttribute(null);
78          req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
79  
80          DefaultActionMapper mapper = new DefaultActionMapper();
81          ActionMapping mapping = mapper.getMapping(req, configManager);
82  
83          assertEquals("/my/namespace", mapping.getNamespace());
84          assertEquals("actionName", mapping.getName());
85          assertNull(mapping.getMethod());
86      }
87  
88      public void testGetMappingWithMethod() throws Exception {
89          req.setupGetParameterMap(new HashMap());
90          req.setupGetRequestURI("/my/namespace/actionName!add.action");
91          req.setupGetServletPath("/my/namespace/actionName!add.action");
92          req.setupGetAttribute(null);
93          req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
94  
95          DefaultActionMapper mapper = new DefaultActionMapper();
96          ActionMapping mapping = mapper.getMapping(req, configManager);
97  
98          assertEquals("/my/namespace", mapping.getNamespace());
99          assertEquals("actionName", mapping.getName());
100         assertEquals("add", mapping.getMethod());
101     }
102 
103     public void testGetMappingWithSlashedName() throws Exception {
104 
105         req.setupGetRequestURI("/my/foo/actionName.action");
106         req.setupGetServletPath("/my/foo/actionName.action");
107         req.setupGetAttribute(null);
108         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
109 
110         DefaultActionMapper mapper = new DefaultActionMapper();
111         mapper.setSlashesInActionNames("true");
112         ActionMapping mapping = mapper.getMapping(req, configManager);
113 
114         assertEquals("/my", mapping.getNamespace());
115         assertEquals("foo/actionName", mapping.getName());
116         assertNull(mapping.getMethod());
117     }
118 
119     public void testGetMappingWithSlashedNameAtRoot() throws Exception {
120 
121         req.setupGetRequestURI("/foo/actionName.action");
122         req.setupGetServletPath("/foo/actionName.action");
123         req.setupGetAttribute(null);
124         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
125 
126         DefaultActionMapper mapper = new DefaultActionMapper();
127         mapper.setSlashesInActionNames("true");
128         ActionMapping mapping = mapper.getMapping(req, configManager);
129 
130         assertEquals("", mapping.getNamespace());
131         assertEquals("foo/actionName", mapping.getName());
132         assertNull(mapping.getMethod());
133     }
134 
135     public void testGetMappingWithNamespaceSlash() throws Exception {
136 
137         req.setupGetRequestURI("/my.hh/abc.action");
138         req.setupGetServletPath("/my.hh/abc.action");
139         req.setupGetAttribute(null);
140         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
141 
142         DefaultActionMapper mapper = new DefaultActionMapper();
143         ActionMapping mapping = mapper.getMapping(req, configManager);
144 
145         assertEquals("", mapping.getNamespace());
146         assertEquals("abc", mapping.getName());
147 
148         req.setupGetAttribute(null);
149         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
150         mapper = new DefaultActionMapper();
151         mapper.setSlashesInActionNames("true");
152         mapping = mapper.getMapping(req, configManager);
153 
154         assertEquals("", mapping.getNamespace());
155         assertEquals("my.hh/abc", mapping.getName());
156     }
157 
158     public void testGetMappingWithUnknownNamespace() throws Exception {
159         req.setupGetRequestURI("/bo/foo/actionName.action");
160         req.setupGetServletPath("/bo/foo/actionName.action");
161         req.setupGetAttribute(null);
162         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
163 
164         DefaultActionMapper mapper = new DefaultActionMapper();
165         ActionMapping mapping = mapper.getMapping(req, configManager);
166 
167         assertEquals("", mapping.getNamespace());
168         assertEquals("actionName", mapping.getName());
169         assertNull(mapping.getMethod());
170     }
171 
172     public void testGetMappingWithUnknownNamespaceButFullNamespaceSelect() throws Exception {
173         req.setupGetRequestURI("/bo/foo/actionName.action");
174         req.setupGetServletPath("/bo/foo/actionName.action");
175         req.setupGetAttribute(null);
176         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
177 
178         DefaultActionMapper mapper = new DefaultActionMapper();
179         mapper.setAlwaysSelectFullNamespace("true");
180         ActionMapping mapping = mapper.getMapping(req, configManager);
181 
182         assertEquals("/bo/foo", mapping.getNamespace());
183         assertEquals("actionName", mapping.getName());
184         assertNull(mapping.getMethod());
185     }
186 
187     public void testGetMappingWithActionName_methodAndName() throws Exception {
188         DefaultActionMapper mapper = new DefaultActionMapper();
189         ActionMapping mapping = mapper.getMappingFromActionName("actionName!add");
190         assertEquals("actionName", mapping.getName());
191         assertEquals("add", mapping.getMethod());
192     }
193 
194     public void testGetMappingWithActionName_name() throws Exception {
195         DefaultActionMapper mapper = new DefaultActionMapper();
196         ActionMapping mapping = mapper.getMappingFromActionName("actionName");
197         assertEquals("actionName", mapping.getName());
198         assertEquals(null, mapping.getMethod());
199     }
200 
201     public void testGetMappingWithActionName_noDynamicMethod() throws Exception {
202         DefaultActionMapper mapper = new DefaultActionMapper();
203         mapper.setAllowDynamicMethodCalls("false");
204         ActionMapping mapping = mapper.getMappingFromActionName("actionName!add");
205         assertEquals("actionName!add", mapping.getName());
206         assertEquals(null, mapping.getMethod());
207     }
208 
209     public void testGetMappingWithActionName_null() throws Exception {
210         DefaultActionMapper mapper = new DefaultActionMapper();
211         ActionMapping mapping = mapper.getMappingFromActionName(null);
212         assertEquals(null, mapping.getName());
213         assertEquals(null, mapping.getMethod());
214     }
215 
216     public void testGetUri() throws Exception {
217         req.setupGetParameterMap(new HashMap());
218         req.setupGetRequestURI("/my/namespace/actionName.action");
219         req.setupGetServletPath("/my/namespace/actionName.action");
220         req.setupGetAttribute(null);
221         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
222 
223         DefaultActionMapper mapper = new DefaultActionMapper();
224         ActionMapping mapping = mapper.getMapping(req, configManager);
225         assertEquals("/my/namespace/actionName.action", mapper.getUriFromActionMapping(mapping));
226     }
227 
228     public void testGetUriWithSemicolonPresent() throws Exception {
229         req.setupGetParameterMap(new HashMap());
230         req.setupGetRequestURI("/my/namespace/actionName.action;abc=123rty56");
231         req.setupGetServletPath("/my/namespace/actionName.action;abc=123rty56");
232         req.setupGetAttribute(null);
233         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
234 
235         DefaultActionMapper mapper = new DefaultActionMapper();
236         ActionMapping mapping = mapper.getMapping(req, configManager);
237         assertEquals("/my/namespace/actionName.action", mapper.getUriFromActionMapping(mapping));
238     }
239 
240     public void testGetUriWithMethod() throws Exception {
241         req.setupGetParameterMap(new HashMap());
242         req.setupGetRequestURI("/my/namespace/actionName!add.action");
243         req.setupGetServletPath("/my/namespace/actionName!add.action");
244         req.setupGetAttribute(null);
245         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
246 
247         DefaultActionMapper mapper = new DefaultActionMapper();
248         ActionMapping mapping = mapper.getMapping(req, configManager);
249 
250         assertEquals("/my/namespace/actionName!add.action", mapper.getUriFromActionMapping(mapping));
251     }
252 
253     public void testGetUriWithOriginalExtension() throws Exception {
254         ActionMapping mapping = new ActionMapping("actionName", "/ns", null, new HashMap());
255 
256         ActionMapping orig = new ActionMapping();
257         orig.setExtension("foo");
258         ActionContext.getContext().put(ServletActionContext.ACTION_MAPPING, orig);
259 
260         DefaultActionMapper mapper = new DefaultActionMapper();
261         assertEquals("/ns/actionName.foo", mapper.getUriFromActionMapping(mapping));
262     }
263 
264     public void testGetMappingWithNoExtension() throws Exception {
265         req.setupGetParameterMap(new HashMap());
266         req.setupGetRequestURI("/my/namespace/actionName");
267         req.setupGetServletPath("/my/namespace/actionName");
268         req.setupGetAttribute(null);
269         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
270 
271         DefaultActionMapper mapper = new DefaultActionMapper();
272         mapper.setExtensions("");
273         ActionMapping mapping = mapper.getMapping(req, configManager);
274 
275         assertEquals("/my/namespace", mapping.getNamespace());
276         assertEquals("actionName", mapping.getName());
277         assertNull(mapping.getMethod());
278     }
279 
280     public void testGetMappingWithNoExtensionButUriHasExtension() throws Exception {
281         req.setupGetParameterMap(new HashMap());
282         req.setupGetRequestURI("/my/namespace/actionName.html");
283         req.setupGetServletPath("/my/namespace/actionName.html");
284         req.setupGetAttribute(null);
285         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
286 
287         DefaultActionMapper mapper = new DefaultActionMapper();
288         mapper.setExtensions("");
289         ActionMapping mapping = mapper.getMapping(req, configManager);
290 
291         assertEquals("/my/namespace", mapping.getNamespace());
292         assertEquals("actionName.html", mapping.getName());
293         assertNull(mapping.getMethod());
294     }
295 
296     // =============================
297     // === test name & namespace ===
298     // =============================
299 
300     public void testParseNameAndNamespace1() throws Exception {
301         ActionMapping actionMapping = new ActionMapping();
302 
303         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
304         defaultActionMapper.parseNameAndNamespace("someAction", actionMapping, configManager);
305 
306         assertEquals(actionMapping.getName(), "someAction");
307         assertEquals(actionMapping.getNamespace(), "");
308     }
309 
310     public void testParseNameAndNamespace2() throws Exception {
311         ActionMapping actionMapping = new ActionMapping();
312 
313         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
314         defaultActionMapper.parseNameAndNamespace("/someAction", actionMapping, configManager);
315 
316         assertEquals(actionMapping.getName(), "someAction");
317         assertEquals(actionMapping.getNamespace(), "/");
318     }
319 
320     public void testParseNameAndNamespace3() throws Exception {
321         ActionMapping actionMapping = new ActionMapping();
322 
323         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
324         defaultActionMapper.parseNameAndNamespace("/my/someAction", actionMapping, configManager);
325 
326         assertEquals(actionMapping.getName(), "someAction");
327         assertEquals(actionMapping.getNamespace(), "/my");
328     }
329 
330     public void testParseNameAndNamespace_NoSlashes() throws Exception {
331         ActionMapping actionMapping = new ActionMapping();
332 
333         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
334         defaultActionMapper.setSlashesInActionNames("false");
335         defaultActionMapper.parseNameAndNamespace("/foo/someAction", actionMapping, configManager);
336 
337         assertEquals(actionMapping.getName(), "someAction");
338         assertEquals(actionMapping.getNamespace(), "");
339     }
340 
341     public void testParseNameAndNamespace_AllowSlashes() throws Exception {
342         ActionMapping actionMapping = new ActionMapping();
343 
344         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
345         defaultActionMapper.setSlashesInActionNames("true");
346         defaultActionMapper.parseNameAndNamespace("/foo/someAction", actionMapping, configManager);
347 
348         assertEquals(actionMapping.getName(), "foo/someAction");
349         assertEquals(actionMapping.getNamespace(), "");
350     }
351 
352 
353     // ===========================
354     // === test special prefix ===
355     // ===========================
356 
357     public void testActionPrefix() throws Exception {
358         Map parameterMap = new HashMap();
359         parameterMap.put(DefaultActionMapper.ACTION_PREFIX + "myAction", "");
360 
361         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
362         request.setParameterMap(parameterMap);
363         request.setupGetServletPath("/someServletPath.action");
364 
365         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
366         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
367 
368         assertEquals(actionMapping.getName(), "myAction");
369     }
370 
371     public void testActionPrefix_fromImageButton() throws Exception {
372         Map parameterMap = new HashMap();
373         parameterMap.put(DefaultActionMapper.ACTION_PREFIX + "myAction", "");
374         parameterMap.put(DefaultActionMapper.ACTION_PREFIX + "myAction.x", "");
375         parameterMap.put(DefaultActionMapper.ACTION_PREFIX + "myAction.y", "");
376 
377         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
378         request.setParameterMap(parameterMap);
379         request.setupGetServletPath("/someServletPath.action");
380 
381         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
382         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
383 
384         assertEquals(actionMapping.getName(), "myAction");
385     }
386 
387     public void testActionPrefix_fromIEImageButton() throws Exception {
388         Map parameterMap = new HashMap();
389         parameterMap.put(DefaultActionMapper.ACTION_PREFIX + "myAction.x", "");
390         parameterMap.put(DefaultActionMapper.ACTION_PREFIX + "myAction.y", "");
391 
392         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
393         request.setParameterMap(parameterMap);
394         request.setupGetServletPath("/someServletPath.action");
395 
396         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
397         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
398 
399         assertEquals(actionMapping.getName(), "myAction");
400     }
401 
402     public void testRedirectPrefix() throws Exception {
403         Map parameterMap = new HashMap();
404         parameterMap.put(DefaultActionMapper.REDIRECT_PREFIX + "http://www.google.com", "");
405 
406         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
407         request.setupGetServletPath("/someServletPath.action");
408         request.setParameterMap(parameterMap);
409 
410         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
411         defaultActionMapper.setContainer(container);
412         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
413 
414         Result result = actionMapping.getResult();
415         assertNotNull(result);
416         assertTrue(result instanceof ServletRedirectResult);
417 
418         Mock invMock = new Mock(ActionInvocation.class);
419         ActionInvocation inv = (ActionInvocation) invMock.proxy();
420         ActionContext ctx = ActionContext.getContext();
421         ctx.put(ServletActionContext.HTTP_REQUEST, request);
422         StrutsMockHttpServletResponse response = new StrutsMockHttpServletResponse();
423         ctx.put(ServletActionContext.HTTP_RESPONSE, response);
424         invMock.expectAndReturn("getInvocationContext", ctx);
425         invMock.expectAndReturn("getStack", ctx.getValueStack());
426         result.execute(inv);
427         assertEquals("http://www.google.com", response.getRedirectURL());
428         //TODO: need to test location but there's noaccess to the property/method, unless we use reflection
429     }
430 
431     public void testRedirectActionPrefix() throws Exception {
432         Map parameterMap = new HashMap();
433         parameterMap.put(DefaultActionMapper.REDIRECT_ACTION_PREFIX + "myAction", "");
434 
435         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
436         request.setupGetServletPath("/someServletPath.action");
437         request.setParameterMap(parameterMap);
438 
439         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
440         defaultActionMapper.setContainer(container);
441         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
442 
443 
444         StrutsResultSupport result = (StrutsResultSupport) actionMapping.getResult();
445         assertNotNull(result);
446         assertTrue(result instanceof ServletRedirectResult);
447 
448         assertEquals("myAction.action", result.getLocation());
449 
450         // TODO: need to test location but there's noaccess to the property/method, unless we use reflection
451     }
452 
453     public void testRedirectActionPrefixWithEmptyExtension() throws Exception {
454         Map parameterMap = new HashMap();
455         parameterMap.put(DefaultActionMapper.REDIRECT_ACTION_PREFIX + "myAction", "");
456 
457         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
458         request.setupGetServletPath("/someServletPath");
459         request.setParameterMap(parameterMap);
460 
461         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
462         defaultActionMapper.setContainer(container);
463         defaultActionMapper.setExtensions(",,");
464         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
465 
466 
467         StrutsResultSupport result = (StrutsResultSupport) actionMapping.getResult();
468         assertNotNull(result);
469         assertTrue(result instanceof ServletRedirectResult);
470 
471         assertEquals("myAction", result.getLocation());
472 
473         // TODO: need to test location but there's noaccess to the property/method, unless we use reflection
474     }
475 
476     public void testCustomActionPrefix() throws Exception {
477         Map parameterMap = new HashMap();
478         parameterMap.put("foo:myAction", "");
479 
480         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
481         request.setParameterMap(parameterMap);
482         request.setupGetServletPath("/someServletPath.action");
483 
484         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
485         defaultActionMapper.addParameterAction("foo", new ParameterAction() {
486             public void execute(String key, ActionMapping mapping) {
487                 mapping.setName("myAction");
488             }
489         });
490         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
491 
492         assertEquals(actionMapping.getName(), "myAction");
493     }
494 
495     public void testDropExtension() throws Exception {
496         DefaultActionMapper mapper = new DefaultActionMapper();
497         String name = mapper.dropExtension("foo.action");
498         assertTrue("Name not right: "+name, "foo".equals(name));
499 
500         name = mapper.dropExtension("foo.action.action");
501         assertTrue("Name not right: "+name, "foo.action".equals(name));
502 
503     }
504 
505     public void testDropExtensionWhenBlank() throws Exception {
506         DefaultActionMapper mapper = new DefaultActionMapper();
507         mapper.setExtensions("action,,");
508         String name = mapper.dropExtension("foo.action");
509         assertTrue("Name not right: "+name, "foo".equals(name));
510         name = mapper.dropExtension("foo");
511         assertTrue("Name not right: "+name, "foo".equals(name));
512         assertNull(mapper.dropExtension("foo.bar"));
513         assertNull(mapper.dropExtension("foo."));
514     }
515 
516     public void testDropExtensionEmbeddedDot() throws Exception {
517         DefaultActionMapper mapper = new DefaultActionMapper();
518         mapper.setExtensions("action,,");
519 
520         String name = mapper.dropExtension("/foo/bar-1.0/baz.action");
521         assertTrue("Name not right: "+name, "/foo/bar-1.0/baz".equals(name));
522 
523         name = mapper.dropExtension("/foo/bar-1.0/baz");
524         assertTrue("Name not right: "+name, "/foo/bar-1.0/baz".equals(name));
525     }
526 
527     public void testGetUriFromActionMapper1() throws Exception {
528         DefaultActionMapper mapper = new DefaultActionMapper();
529         ActionMapping actionMapping = new ActionMapping();
530         actionMapping.setMethod("myMethod");
531         actionMapping.setName("myActionName");
532         actionMapping.setNamespace("/myNamespace");
533         String uri = mapper.getUriFromActionMapping(actionMapping);
534 
535         assertEquals("/myNamespace/myActionName!myMethod.action", uri);
536     }
537 
538     public void testGetUriFromActionMapper2() throws Exception {
539         DefaultActionMapper mapper = new DefaultActionMapper();
540         ActionMapping actionMapping = new ActionMapping();
541         actionMapping.setMethod("myMethod");
542         actionMapping.setName("myActionName");
543         actionMapping.setNamespace("/");
544         String uri = mapper.getUriFromActionMapping(actionMapping);
545 
546         assertEquals("/myActionName!myMethod.action", uri);
547     }
548 
549     public void testGetUriFromActionMapper3() throws Exception {
550         DefaultActionMapper mapper = new DefaultActionMapper();
551         ActionMapping actionMapping = new ActionMapping();
552         actionMapping.setMethod("myMethod");
553         actionMapping.setName("myActionName");
554         actionMapping.setNamespace("");
555         String uri = mapper.getUriFromActionMapping(actionMapping);
556 
557         assertEquals("/myActionName!myMethod.action", uri);
558     }
559 
560 
561     public void testGetUriFromActionMapper4() throws Exception {
562         DefaultActionMapper mapper = new DefaultActionMapper();
563         ActionMapping actionMapping = new ActionMapping();
564         actionMapping.setName("myActionName");
565         actionMapping.setNamespace("");
566         String uri = mapper.getUriFromActionMapping(actionMapping);
567 
568         assertEquals("/myActionName.action", uri);
569     }
570 
571     public void testGetUriFromActionMapper5() throws Exception {
572         DefaultActionMapper mapper = new DefaultActionMapper();
573         ActionMapping actionMapping = new ActionMapping();
574         actionMapping.setName("myActionName");
575         actionMapping.setNamespace("/");
576         String uri = mapper.getUriFromActionMapping(actionMapping);
577 
578         assertEquals("/myActionName.action", uri);
579     }
580 
581     //
582     public void testGetUriFromActionMapper6() throws Exception {
583         DefaultActionMapper mapper = new DefaultActionMapper();
584         ActionMapping actionMapping = new ActionMapping();
585         actionMapping.setMethod("myMethod");
586         actionMapping.setName("myActionName?test=bla");
587         actionMapping.setNamespace("/myNamespace");
588         String uri = mapper.getUriFromActionMapping(actionMapping);
589 
590         assertEquals("/myNamespace/myActionName!myMethod.action?test=bla", uri);
591     }
592 
593     public void testGetUriFromActionMapper7() throws Exception {
594         DefaultActionMapper mapper = new DefaultActionMapper();
595         ActionMapping actionMapping = new ActionMapping();
596         actionMapping.setMethod("myMethod");
597         actionMapping.setName("myActionName?test=bla");
598         actionMapping.setNamespace("/");
599         String uri = mapper.getUriFromActionMapping(actionMapping);
600 
601         assertEquals("/myActionName!myMethod.action?test=bla", uri);
602     }
603 
604     public void testGetUriFromActionMapper8() throws Exception {
605         DefaultActionMapper mapper = new DefaultActionMapper();
606         ActionMapping actionMapping = new ActionMapping();
607         actionMapping.setMethod("myMethod");
608         actionMapping.setName("myActionName?test=bla");
609         actionMapping.setNamespace("");
610         String uri = mapper.getUriFromActionMapping(actionMapping);
611 
612         assertEquals("/myActionName!myMethod.action?test=bla", uri);
613     }
614 
615 
616     public void testGetUriFromActionMapper9() throws Exception {
617         DefaultActionMapper mapper = new DefaultActionMapper();
618         ActionMapping actionMapping = new ActionMapping();
619         actionMapping.setName("myActionName?test=bla");
620         actionMapping.setNamespace("");
621         String uri = mapper.getUriFromActionMapping(actionMapping);
622 
623         assertEquals("/myActionName.action?test=bla", uri);
624     }
625 
626     public void testGetUriFromActionMapper10() throws Exception {
627         DefaultActionMapper mapper = new DefaultActionMapper();
628         ActionMapping actionMapping = new ActionMapping();
629         actionMapping.setName("myActionName?test=bla");
630         actionMapping.setNamespace("/");
631         String uri = mapper.getUriFromActionMapping(actionMapping);
632 
633         assertEquals("/myActionName.action?test=bla", uri);
634     }
635 
636     public void testGetUriFromActionMapper11() throws Exception {
637         DefaultActionMapper mapper = new DefaultActionMapper();
638         ActionMapping actionMapping = new ActionMapping();
639         actionMapping.setName("myActionName.action");
640         actionMapping.setNamespace("/");
641         String uri = mapper.getUriFromActionMapping(actionMapping);
642 
643         assertEquals("/myActionName.action", uri);
644     }
645 
646     public void testGetUriFromActionMapper12() throws Exception {
647         DefaultActionMapper mapper = new DefaultActionMapper();
648         ActionMapping actionMapping = new ActionMapping();
649         actionMapping.setName("myActionName.action");
650         actionMapping.setNamespace("/");
651         String uri = mapper.getUriFromActionMapping(actionMapping);
652 
653         assertEquals("/myActionName.action", uri);
654     }
655 
656     public void testGetUriFromActionMapper_justActionAndMethod() throws Exception {
657         DefaultActionMapper mapper = new DefaultActionMapper();
658         ActionMapping actionMapping = new ActionMapping();
659         actionMapping.setMethod("myMethod");
660         actionMapping.setName("myActionName");
661         actionMapping.setExtension("");
662         String uri = mapper.getUriFromActionMapping(actionMapping);
663 
664         assertEquals("myActionName!myMethod", uri);
665     }
666 
667     public void testGetUriFromActionMapperWhenBlankExtension() throws Exception {
668         DefaultActionMapper mapper = new DefaultActionMapper();
669         mapper.setExtensions(",,");
670         ActionMapping actionMapping = new ActionMapping();
671         actionMapping.setMethod("myMethod");
672         actionMapping.setName("myActionName");
673         actionMapping.setNamespace("/myNamespace");
674         String uri = mapper.getUriFromActionMapping(actionMapping);
675 
676         assertEquals("/myNamespace/myActionName!myMethod", uri);
677     }
678 
679     public void testSetExtension() throws Exception {
680         DefaultActionMapper mapper = new DefaultActionMapper();
681         mapper.setExtensions("");
682         assertNull(mapper.extensions);
683         mapper.setExtensions(null);
684         assertNull(mapper.extensions);
685 
686         mapper.setExtensions(",xml");
687         assertEquals(Arrays.asList("", "xml"), mapper.extensions);
688 
689         mapper.setExtensions("html,xml,");
690         assertEquals(Arrays.asList("html", "xml", ""), mapper.extensions);
691 
692         mapper.setExtensions("html,,xml");
693         assertEquals(Arrays.asList("html", "", "xml"), mapper.extensions);
694 
695         mapper.setExtensions("xml");
696         assertEquals(Arrays.asList("xml"), mapper.extensions);
697 
698         mapper.setExtensions(",");
699         assertEquals(Arrays.asList(""), mapper.extensions);
700 
701 
702     }
703 
704 }