View Javadoc

1   /*
2    * $Id: DefaultActionMapperTest.java 780092 2009-05-29 20:15:14Z wesw $
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_noDynamicMethodColonPrefix() throws Exception {
241 
242         Map parameterMap = new HashMap();
243         parameterMap.put(DefaultActionMapper.METHOD_PREFIX + "someMethod", "");
244 
245         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
246         request.setParameterMap(parameterMap);
247         request.setupGetServletPath("/someServletPath.action");
248 
249         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
250         defaultActionMapper.setAllowDynamicMethodCalls("false");
251         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
252 
253         assertEquals("someServletPath", actionMapping.getName());
254         assertEquals(null, actionMapping.getMethod());
255     }
256 
257     public void testGetMappingWithActionName_null() throws Exception {
258         DefaultActionMapper mapper = new DefaultActionMapper();
259         ActionMapping mapping = mapper.getMappingFromActionName(null);
260         assertEquals(null, mapping.getName());
261         assertEquals(null, mapping.getMethod());
262     }
263 
264     public void testGetUri() throws Exception {
265         req.setupGetParameterMap(new HashMap());
266         req.setupGetRequestURI("/my/namespace/actionName.action");
267         req.setupGetServletPath("/my/namespace/actionName.action");
268         req.setupGetAttribute(null);
269         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
270 
271         DefaultActionMapper mapper = new DefaultActionMapper();
272         ActionMapping mapping = mapper.getMapping(req, configManager);
273         assertEquals("/my/namespace/actionName.action", mapper.getUriFromActionMapping(mapping));
274     }
275 
276     public void testGetUriWithSemicolonPresent() throws Exception {
277         req.setupGetParameterMap(new HashMap());
278         req.setupGetRequestURI("/my/namespace/actionName.action;abc=123rty56");
279         req.setupGetServletPath("/my/namespace/actionName.action;abc=123rty56");
280         req.setupGetAttribute(null);
281         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
282 
283         DefaultActionMapper mapper = new DefaultActionMapper();
284         ActionMapping mapping = mapper.getMapping(req, configManager);
285         assertEquals("/my/namespace/actionName.action", mapper.getUriFromActionMapping(mapping));
286     }
287 
288     public void testGetUriWithMethod() throws Exception {
289         req.setupGetParameterMap(new HashMap());
290         req.setupGetRequestURI("/my/namespace/actionName!add.action");
291         req.setupGetServletPath("/my/namespace/actionName!add.action");
292         req.setupGetAttribute(null);
293         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
294 
295         DefaultActionMapper mapper = new DefaultActionMapper();
296         ActionMapping mapping = mapper.getMapping(req, configManager);
297 
298         assertEquals("/my/namespace/actionName!add.action", mapper.getUriFromActionMapping(mapping));
299     }
300 
301     public void testGetUriWithOriginalExtension() throws Exception {
302         ActionMapping mapping = new ActionMapping("actionName", "/ns", null, new HashMap());
303 
304         ActionMapping orig = new ActionMapping();
305         orig.setExtension("foo");
306         ActionContext.getContext().put(ServletActionContext.ACTION_MAPPING, orig);
307 
308         DefaultActionMapper mapper = new DefaultActionMapper();
309         assertEquals("/ns/actionName.foo", mapper.getUriFromActionMapping(mapping));
310     }
311 
312     public void testGetMappingWithNoExtension() throws Exception {
313         req.setupGetParameterMap(new HashMap());
314         req.setupGetRequestURI("/my/namespace/actionName");
315         req.setupGetServletPath("/my/namespace/actionName");
316         req.setupGetAttribute(null);
317         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
318 
319         DefaultActionMapper mapper = new DefaultActionMapper();
320         mapper.setExtensions("");
321         ActionMapping mapping = mapper.getMapping(req, configManager);
322 
323         assertEquals("/my/namespace", mapping.getNamespace());
324         assertEquals("actionName", mapping.getName());
325         assertNull(mapping.getMethod());
326     }
327 
328     public void testGetMappingWithNoExtensionButUriHasExtension() throws Exception {
329         req.setupGetParameterMap(new HashMap());
330         req.setupGetRequestURI("/my/namespace/actionName.html");
331         req.setupGetServletPath("/my/namespace/actionName.html");
332         req.setupGetAttribute(null);
333         req.addExpectedGetAttributeName("javax.servlet.include.servlet_path");
334 
335         DefaultActionMapper mapper = new DefaultActionMapper();
336         mapper.setExtensions("");
337         ActionMapping mapping = mapper.getMapping(req, configManager);
338 
339         assertEquals("/my/namespace", mapping.getNamespace());
340         assertEquals("actionName.html", mapping.getName());
341         assertNull(mapping.getMethod());
342     }
343 
344     // =============================
345     // === test name & namespace ===
346     // =============================
347 
348     public void testParseNameAndNamespace1() throws Exception {
349         ActionMapping actionMapping = new ActionMapping();
350 
351         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
352         defaultActionMapper.parseNameAndNamespace("someAction", actionMapping, configManager);
353 
354         assertEquals(actionMapping.getName(), "someAction");
355         assertEquals(actionMapping.getNamespace(), "");
356     }
357 
358     public void testParseNameAndNamespace2() throws Exception {
359         ActionMapping actionMapping = new ActionMapping();
360 
361         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
362         defaultActionMapper.parseNameAndNamespace("/someAction", actionMapping, configManager);
363 
364         assertEquals(actionMapping.getName(), "someAction");
365         assertEquals(actionMapping.getNamespace(), "/");
366     }
367 
368     public void testParseNameAndNamespace3() throws Exception {
369         ActionMapping actionMapping = new ActionMapping();
370 
371         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
372         defaultActionMapper.parseNameAndNamespace("/my/someAction", actionMapping, configManager);
373 
374         assertEquals(actionMapping.getName(), "someAction");
375         assertEquals(actionMapping.getNamespace(), "/my");
376     }
377 
378     public void testParseNameAndNamespace_NoSlashes() throws Exception {
379         ActionMapping actionMapping = new ActionMapping();
380 
381         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
382         defaultActionMapper.setSlashesInActionNames("false");
383         defaultActionMapper.parseNameAndNamespace("/foo/someAction", actionMapping, configManager);
384 
385         assertEquals(actionMapping.getName(), "someAction");
386         assertEquals(actionMapping.getNamespace(), "");
387     }
388 
389     public void testParseNameAndNamespace_AllowSlashes() throws Exception {
390         ActionMapping actionMapping = new ActionMapping();
391 
392         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
393         defaultActionMapper.setSlashesInActionNames("true");
394         defaultActionMapper.parseNameAndNamespace("/foo/someAction", actionMapping, configManager);
395 
396         assertEquals(actionMapping.getName(), "foo/someAction");
397         assertEquals(actionMapping.getNamespace(), "");
398     }
399 
400 
401     // ===========================
402     // === test special prefix ===
403     // ===========================
404 
405     public void testActionPrefix() throws Exception {
406         Map parameterMap = new HashMap();
407         parameterMap.put(DefaultActionMapper.ACTION_PREFIX + "myAction", "");
408 
409         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
410         request.setParameterMap(parameterMap);
411         request.setupGetServletPath("/someServletPath.action");
412 
413         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
414         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
415 
416         assertEquals(actionMapping.getName(), "myAction");
417     }
418 
419     public void testActionPrefix_fromImageButton() throws Exception {
420         Map parameterMap = new HashMap();
421         parameterMap.put(DefaultActionMapper.ACTION_PREFIX + "myAction", "");
422         parameterMap.put(DefaultActionMapper.ACTION_PREFIX + "myAction.x", "");
423         parameterMap.put(DefaultActionMapper.ACTION_PREFIX + "myAction.y", "");
424 
425         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
426         request.setParameterMap(parameterMap);
427         request.setupGetServletPath("/someServletPath.action");
428 
429         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
430         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
431 
432         assertEquals(actionMapping.getName(), "myAction");
433     }
434 
435     public void testActionPrefix_fromIEImageButton() throws Exception {
436         Map parameterMap = new HashMap();
437         parameterMap.put(DefaultActionMapper.ACTION_PREFIX + "myAction.x", "");
438         parameterMap.put(DefaultActionMapper.ACTION_PREFIX + "myAction.y", "");
439 
440         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
441         request.setParameterMap(parameterMap);
442         request.setupGetServletPath("/someServletPath.action");
443 
444         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
445         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
446 
447         assertEquals(actionMapping.getName(), "myAction");
448     }
449 
450     public void testRedirectPrefix() throws Exception {
451         Map parameterMap = new HashMap();
452         parameterMap.put(DefaultActionMapper.REDIRECT_PREFIX + "http://www.google.com", "");
453 
454         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
455         request.setupGetServletPath("/someServletPath.action");
456         request.setParameterMap(parameterMap);
457 
458         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
459         defaultActionMapper.setContainer(container);
460         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
461 
462         Result result = actionMapping.getResult();
463         assertNotNull(result);
464         assertTrue(result instanceof ServletRedirectResult);
465 
466         Mock invMock = new Mock(ActionInvocation.class);
467         ActionInvocation inv = (ActionInvocation) invMock.proxy();
468         ActionContext ctx = ActionContext.getContext();
469         ctx.put(ServletActionContext.HTTP_REQUEST, request);
470         StrutsMockHttpServletResponse response = new StrutsMockHttpServletResponse();
471         ctx.put(ServletActionContext.HTTP_RESPONSE, response);
472         invMock.expectAndReturn("getInvocationContext", ctx);
473         invMock.expectAndReturn("getStack", ctx.getValueStack());
474         result.execute(inv);
475         assertEquals("http://www.google.com", response.getRedirectURL());
476         //TODO: need to test location but there's noaccess to the property/method, unless we use reflection
477     }
478 
479     public void testRedirectActionPrefix() throws Exception {
480         Map parameterMap = new HashMap();
481         parameterMap.put(DefaultActionMapper.REDIRECT_ACTION_PREFIX + "myAction", "");
482 
483         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
484         request.setupGetServletPath("/someServletPath.action");
485         request.setParameterMap(parameterMap);
486 
487         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
488         defaultActionMapper.setContainer(container);
489         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
490 
491 
492         StrutsResultSupport result = (StrutsResultSupport) actionMapping.getResult();
493         assertNotNull(result);
494         assertTrue(result instanceof ServletRedirectResult);
495 
496         assertEquals("myAction.action", result.getLocation());
497 
498         // TODO: need to test location but there's noaccess to the property/method, unless we use reflection
499     }
500 
501     public void testRedirectActionPrefixWithEmptyExtension() throws Exception {
502         Map parameterMap = new HashMap();
503         parameterMap.put(DefaultActionMapper.REDIRECT_ACTION_PREFIX + "myAction", "");
504 
505         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
506         request.setupGetServletPath("/someServletPath");
507         request.setParameterMap(parameterMap);
508 
509         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
510         defaultActionMapper.setContainer(container);
511         defaultActionMapper.setExtensions(",,");
512         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
513 
514 
515         StrutsResultSupport result = (StrutsResultSupport) actionMapping.getResult();
516         assertNotNull(result);
517         assertTrue(result instanceof ServletRedirectResult);
518 
519         assertEquals("myAction", result.getLocation());
520 
521         // TODO: need to test location but there's noaccess to the property/method, unless we use reflection
522     }
523 
524     public void testCustomActionPrefix() throws Exception {
525         Map parameterMap = new HashMap();
526         parameterMap.put("foo:myAction", "");
527 
528         StrutsMockHttpServletRequest request = new StrutsMockHttpServletRequest();
529         request.setParameterMap(parameterMap);
530         request.setupGetServletPath("/someServletPath.action");
531 
532         DefaultActionMapper defaultActionMapper = new DefaultActionMapper();
533         defaultActionMapper.addParameterAction("foo", new ParameterAction() {
534             public void execute(String key, ActionMapping mapping) {
535                 mapping.setName("myAction");
536             }
537         });
538         ActionMapping actionMapping = defaultActionMapper.getMapping(request, configManager);
539 
540         assertEquals(actionMapping.getName(), "myAction");
541     }
542 
543     public void testDropExtension() throws Exception {
544         DefaultActionMapper mapper = new DefaultActionMapper();
545         String name = mapper.dropExtension("foo.action");
546         assertTrue("Name not right: "+name, "foo".equals(name));
547 
548         name = mapper.dropExtension("foo.action.action");
549         assertTrue("Name not right: "+name, "foo.action".equals(name));
550 
551     }
552 
553     public void testDropExtensionWhenBlank() throws Exception {
554         DefaultActionMapper mapper = new DefaultActionMapper();
555         mapper.setExtensions("action,,");
556         String name = mapper.dropExtension("foo.action");
557         assertTrue("Name not right: "+name, "foo".equals(name));
558         name = mapper.dropExtension("foo");
559         assertTrue("Name not right: "+name, "foo".equals(name));
560         assertNull(mapper.dropExtension("foo.bar"));
561         assertNull(mapper.dropExtension("foo."));
562     }
563 
564     public void testDropExtensionEmbeddedDot() throws Exception {
565         DefaultActionMapper mapper = new DefaultActionMapper();
566         mapper.setExtensions("action,,");
567 
568         String name = mapper.dropExtension("/foo/bar-1.0/baz.action");
569         assertTrue("Name not right: "+name, "/foo/bar-1.0/baz".equals(name));
570 
571         name = mapper.dropExtension("/foo/bar-1.0/baz");
572         assertTrue("Name not right: "+name, "/foo/bar-1.0/baz".equals(name));
573     }
574 
575     public void testGetUriFromActionMapper1() throws Exception {
576         DefaultActionMapper mapper = new DefaultActionMapper();
577         ActionMapping actionMapping = new ActionMapping();
578         actionMapping.setMethod("myMethod");
579         actionMapping.setName("myActionName");
580         actionMapping.setNamespace("/myNamespace");
581         String uri = mapper.getUriFromActionMapping(actionMapping);
582 
583         assertEquals("/myNamespace/myActionName!myMethod.action", uri);
584     }
585 
586     public void testGetUriFromActionMapper2() throws Exception {
587         DefaultActionMapper mapper = new DefaultActionMapper();
588         ActionMapping actionMapping = new ActionMapping();
589         actionMapping.setMethod("myMethod");
590         actionMapping.setName("myActionName");
591         actionMapping.setNamespace("/");
592         String uri = mapper.getUriFromActionMapping(actionMapping);
593 
594         assertEquals("/myActionName!myMethod.action", uri);
595     }
596 
597     public void testGetUriFromActionMapper3() throws Exception {
598         DefaultActionMapper mapper = new DefaultActionMapper();
599         ActionMapping actionMapping = new ActionMapping();
600         actionMapping.setMethod("myMethod");
601         actionMapping.setName("myActionName");
602         actionMapping.setNamespace("");
603         String uri = mapper.getUriFromActionMapping(actionMapping);
604 
605         assertEquals("/myActionName!myMethod.action", uri);
606     }
607 
608 
609     public void testGetUriFromActionMapper4() throws Exception {
610         DefaultActionMapper mapper = new DefaultActionMapper();
611         ActionMapping actionMapping = new ActionMapping();
612         actionMapping.setName("myActionName");
613         actionMapping.setNamespace("");
614         String uri = mapper.getUriFromActionMapping(actionMapping);
615 
616         assertEquals("/myActionName.action", uri);
617     }
618 
619     public void testGetUriFromActionMapper5() throws Exception {
620         DefaultActionMapper mapper = new DefaultActionMapper();
621         ActionMapping actionMapping = new ActionMapping();
622         actionMapping.setName("myActionName");
623         actionMapping.setNamespace("/");
624         String uri = mapper.getUriFromActionMapping(actionMapping);
625 
626         assertEquals("/myActionName.action", uri);
627     }
628 
629     //
630     public void testGetUriFromActionMapper6() throws Exception {
631         DefaultActionMapper mapper = new DefaultActionMapper();
632         ActionMapping actionMapping = new ActionMapping();
633         actionMapping.setMethod("myMethod");
634         actionMapping.setName("myActionName?test=bla");
635         actionMapping.setNamespace("/myNamespace");
636         String uri = mapper.getUriFromActionMapping(actionMapping);
637 
638         assertEquals("/myNamespace/myActionName!myMethod.action?test=bla", uri);
639     }
640 
641     public void testGetUriFromActionMapper7() throws Exception {
642         DefaultActionMapper mapper = new DefaultActionMapper();
643         ActionMapping actionMapping = new ActionMapping();
644         actionMapping.setMethod("myMethod");
645         actionMapping.setName("myActionName?test=bla");
646         actionMapping.setNamespace("/");
647         String uri = mapper.getUriFromActionMapping(actionMapping);
648 
649         assertEquals("/myActionName!myMethod.action?test=bla", uri);
650     }
651 
652     public void testGetUriFromActionMapper8() throws Exception {
653         DefaultActionMapper mapper = new DefaultActionMapper();
654         ActionMapping actionMapping = new ActionMapping();
655         actionMapping.setMethod("myMethod");
656         actionMapping.setName("myActionName?test=bla");
657         actionMapping.setNamespace("");
658         String uri = mapper.getUriFromActionMapping(actionMapping);
659 
660         assertEquals("/myActionName!myMethod.action?test=bla", uri);
661     }
662 
663 
664     public void testGetUriFromActionMapper9() throws Exception {
665         DefaultActionMapper mapper = new DefaultActionMapper();
666         ActionMapping actionMapping = new ActionMapping();
667         actionMapping.setName("myActionName?test=bla");
668         actionMapping.setNamespace("");
669         String uri = mapper.getUriFromActionMapping(actionMapping);
670 
671         assertEquals("/myActionName.action?test=bla", uri);
672     }
673 
674     public void testGetUriFromActionMapper10() throws Exception {
675         DefaultActionMapper mapper = new DefaultActionMapper();
676         ActionMapping actionMapping = new ActionMapping();
677         actionMapping.setName("myActionName?test=bla");
678         actionMapping.setNamespace("/");
679         String uri = mapper.getUriFromActionMapping(actionMapping);
680 
681         assertEquals("/myActionName.action?test=bla", uri);
682     }
683 
684     public void testGetUriFromActionMapper11() throws Exception {
685         DefaultActionMapper mapper = new DefaultActionMapper();
686         ActionMapping actionMapping = new ActionMapping();
687         actionMapping.setName("myActionName.action");
688         actionMapping.setNamespace("/");
689         String uri = mapper.getUriFromActionMapping(actionMapping);
690 
691         assertEquals("/myActionName.action", uri);
692     }
693 
694     public void testGetUriFromActionMapper12() throws Exception {
695         DefaultActionMapper mapper = new DefaultActionMapper();
696         ActionMapping actionMapping = new ActionMapping();
697         actionMapping.setName("myActionName.action");
698         actionMapping.setNamespace("/");
699         String uri = mapper.getUriFromActionMapping(actionMapping);
700 
701         assertEquals("/myActionName.action", uri);
702     }
703 
704     public void testGetUriFromActionMapper_justActionAndMethod() throws Exception {
705         DefaultActionMapper mapper = new DefaultActionMapper();
706         ActionMapping actionMapping = new ActionMapping();
707         actionMapping.setMethod("myMethod");
708         actionMapping.setName("myActionName");
709         actionMapping.setExtension("");
710         String uri = mapper.getUriFromActionMapping(actionMapping);
711 
712         assertEquals("myActionName!myMethod", uri);
713     }
714 
715     public void testGetUriFromActionMapperWhenBlankExtension() throws Exception {
716         DefaultActionMapper mapper = new DefaultActionMapper();
717         mapper.setExtensions(",,");
718         ActionMapping actionMapping = new ActionMapping();
719         actionMapping.setMethod("myMethod");
720         actionMapping.setName("myActionName");
721         actionMapping.setNamespace("/myNamespace");
722         String uri = mapper.getUriFromActionMapping(actionMapping);
723 
724         assertEquals("/myNamespace/myActionName!myMethod", uri);
725     }
726 
727     public void testSetExtension() throws Exception {
728         DefaultActionMapper mapper = new DefaultActionMapper();
729         mapper.setExtensions("");
730         assertNull(mapper.extensions);
731         mapper.setExtensions(null);
732         assertNull(mapper.extensions);
733 
734         mapper.setExtensions(",xml");
735         assertEquals(Arrays.asList("", "xml"), mapper.extensions);
736 
737         mapper.setExtensions("html,xml,");
738         assertEquals(Arrays.asList("html", "xml", ""), mapper.extensions);
739 
740         mapper.setExtensions("html,,xml");
741         assertEquals(Arrays.asList("html", "", "xml"), mapper.extensions);
742 
743         mapper.setExtensions("xml");
744         assertEquals(Arrays.asList("xml"), mapper.extensions);
745 
746         mapper.setExtensions(",");
747         assertEquals(Arrays.asList(""), mapper.extensions);
748 
749 
750     }
751 
752 }