1   /*
2    * $Id: TestActionConfigMatcher.java 471754 2006-11-06 14:55:09Z husted $
3    *
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  package org.apache.struts.config;
22  
23  import junit.framework.Test;
24  import junit.framework.TestSuite;
25  
26  import org.apache.struts.action.ActionForward;
27  import org.apache.struts.action.ActionMapping;
28  import org.apache.struts.mock.TestMockBase;
29  
30  /**
31   * <p>Unit tests for <code>org.apache.struts.util.ActionConfigMatcher</code>.</p>
32   *
33   * @version $Rev: 471754 $ $Date: 2005-10-27 23:25:01 -0400 (Thu, 27 Oct 2005)
34   *          $
35   */
36  public class TestActionConfigMatcher extends TestMockBase {
37      // ----------------------------------------------------------------- Basics
38      public TestActionConfigMatcher(String name) {
39          super(name);
40      }
41  
42      public static void main(String[] args) {
43          junit.awtui.TestRunner.main(new String[] {
44                  TestActionConfigMatcher.class.getName()
45              });
46      }
47  
48      public static Test suite() {
49          return (new TestSuite(TestActionConfigMatcher.class));
50      }
51  
52      // ----------------------------------------------------- Instance Variables
53      // ----------------------------------------------------- Setup and Teardown
54      public void setUp() {
55          super.setUp();
56      }
57  
58      public void tearDown() {
59          super.tearDown();
60      }
61  
62      // ------------------------------------------------------- Individual Tests
63      // ---------------------------------------------------------- match()
64      public void testNoMatch() {
65          ActionConfig[] configs = new ActionConfig[1];
66          ActionConfig mapping = buildActionConfig("/foo");
67  
68          configs[0] = mapping;
69  
70          ActionConfigMatcher matcher = new ActionConfigMatcher(configs);
71  
72          assertNull("ActionConfig shouldn't be matched", matcher.match("/test"));
73      }
74  
75      public void testNoWildcardMatch() {
76          ActionConfig[] configs = new ActionConfig[1];
77          ActionConfig mapping = buildActionConfig("/fooBar");
78  
79          configs[0] = mapping;
80  
81          ActionConfigMatcher matcher = new ActionConfigMatcher(configs);
82  
83          assertNull("ActionConfig shouldn't be matched", matcher.match("/fooBar"));
84      }
85  
86      public void testShouldMatch() {
87          ActionConfig[] configs = new ActionConfig[1];
88          ActionConfig mapping = buildActionConfig("/foo*");
89  
90          configs[0] = mapping;
91  
92          ActionConfigMatcher matcher = new ActionConfigMatcher(configs);
93  
94          ActionConfig matched = matcher.match("/fooBar");
95  
96          assertNotNull("ActionConfig should be matched", matched);
97          assertTrue("ActionConfig should have two action forward",
98              matched.findForwardConfigs().length == 2);
99          assertTrue("ActionConfig should have two exception forward",
100             matched.findExceptionConfigs().length == 2);
101         assertTrue("ActionConfig should have properties",
102             matched.getProperties().size() == 2);
103     }
104 
105     public void testCheckSubstitutionsMatch() {
106         ActionConfig[] configs = new ActionConfig[1];
107         ActionConfig mapping = buildActionConfig("/foo*");
108 
109         configs[0] = mapping;
110 
111         ActionConfigMatcher matcher = new ActionConfigMatcher(configs);
112         ActionConfig m = matcher.match("/fooBar");
113 
114         assertTrue("Name hasn't been replaced", "name,Bar".equals(m.getName()));
115         assertTrue("Path hasn't been replaced", "/fooBar".equals(m.getPath()));
116         assertTrue("Scope isn't correct", "request".equals(m.getScope()));
117         assertTrue("Unknown isn't correct", !m.getUnknown());
118         assertTrue("Validate isn't correct", m.getValidate());
119 
120         assertTrue("Prefix hasn't been replaced",
121             "foo,Bar".equals(m.getPrefix()));
122         assertTrue("Suffix hasn't been replaced",
123             "bar,Bar".equals(m.getSuffix()));
124         assertTrue("Type hasn't been replaced",
125             "foo.bar.BarAction".equals(m.getType()));
126         assertTrue("Roles hasn't been replaced",
127             "public,Bar".equals(m.getRoles()));
128         assertTrue("Parameter hasn't been replaced",
129             "param,Bar".equals(m.getParameter()));
130         assertTrue("Attribute hasn't been replaced",
131             "attrib,Bar".equals(m.getAttribute()));
132         assertTrue("Forward hasn't been replaced",
133             "fwd,Bar".equals(m.getForward()));
134         assertTrue("Include hasn't been replaced",
135             "include,Bar".equals(m.getInclude()));
136         assertTrue("Input hasn't been replaced",
137             "input,Bar".equals(m.getInput()));
138 
139         assertTrue("ActionConfig property not replaced",
140             "testBar".equals(m.getProperty("testprop2")));
141 
142         ForwardConfig[] fConfigs = m.findForwardConfigs();
143         boolean found = false;
144 
145         for (int x = 0; x < fConfigs.length; x++) {
146             ForwardConfig cfg = fConfigs[x];
147 
148             if ("name".equals(cfg.getName())) {
149                 found = true;
150                 assertTrue("Path hasn't been replaced",
151                     "path,Bar".equals(cfg.getPath()));
152                 assertTrue("Property foo hasn't been replaced",
153                     "bar,Bar".equals(cfg.getProperty("foo")));
154                 assertTrue("Module hasn't been replaced",
155                     "modBar".equals(cfg.getModule()));
156             }
157         }
158 
159         assertTrue("The forward config 'name' cannot be found", found);
160     }
161 
162     public void testCheckMultipleSubstitutions() {
163         ActionMapping[] mapping = new ActionMapping[1];
164 
165         mapping[0] = new ActionMapping();
166         mapping[0].setPath("/foo*");
167         mapping[0].setName("name,{1}-{1}");
168 
169         ActionConfigMatcher matcher = new ActionConfigMatcher(mapping);
170         ActionConfig m = matcher.match("/fooBar");
171 
172         assertTrue("Name hasn't been replaced correctly: " + m.getName(),
173             "name,Bar-Bar".equals(m.getName()));
174     }
175 
176     private ActionConfig buildActionConfig(String path) {
177         ActionMapping mapping = new ActionMapping();
178 
179         mapping.setName("name,{1}");
180         mapping.setPath(path);
181         mapping.setScope("request");
182         mapping.setUnknown(false);
183         mapping.setValidate(true);
184 
185         mapping.setPrefix("foo,{1}");
186         mapping.setSuffix("bar,{1}");
187 
188         mapping.setType("foo.bar.{1}Action");
189         mapping.setRoles("public,{1}");
190         mapping.setParameter("param,{1}");
191         mapping.setAttribute("attrib,{1}");
192         mapping.setForward("fwd,{1}");
193         mapping.setInclude("include,{1}");
194         mapping.setInput("input,{1}");
195 
196         ForwardConfig cfg = new ActionForward();
197 
198         cfg.setName("name");
199         cfg.setPath("path,{1}");
200         cfg.setModule("mod{1}");
201         cfg.setProperty("foo", "bar,{1}");
202         mapping.addForwardConfig(cfg);
203 
204         cfg = new ActionForward();
205         cfg.setName("name2");
206         cfg.setPath("path2");
207         cfg.setModule("mod{1}");
208         mapping.addForwardConfig(cfg);
209 
210         ExceptionConfig excfg = new ExceptionConfig();
211 
212         excfg.setKey("foo");
213         excfg.setType("foo.Bar");
214         excfg.setPath("path");
215         mapping.addExceptionConfig(excfg);
216 
217         excfg = new ExceptionConfig();
218         excfg.setKey("foo2");
219         excfg.setType("foo.Bar2");
220         excfg.setPath("path2");
221         mapping.addExceptionConfig(excfg);
222 
223         mapping.setProperty("testprop", "testval");
224         mapping.setProperty("testprop2", "test{1}");
225 
226         mapping.freeze();
227 
228         return mapping;
229     }
230 }