View Javadoc

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