1   /*
2    * $Id: TestForwardConfig.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.TestCase;
25  import junit.framework.TestSuite;
26  
27  /**
28   * <p>Unit tests for ForwardConfig.  Currently contains tests for methods
29   * supporting configuration inheritance.</p>
30   *
31   * @version $Rev: 471754 $ $Date: 2005-05-21 19:06:53 -0400 (Sat, 21 May 2005)
32   *          $
33   */
34  public class TestForwardConfig extends TestCase {
35      // ----------------------------------------------------- Instance Variables
36  
37      /**
38       * The ModuleConfig we'll use.
39       */
40      protected ModuleConfig moduleConfig = null;
41  
42      /**
43       * The common base we'll use.
44       */
45      protected ForwardConfig baseConfig = null;
46  
47      /**
48       * The common subForward we'll use.
49       */
50      protected ForwardConfig subConfig = null;
51  
52      /**
53       * A ForwardConfig we'll use to test cases where a ForwardConfig declared
54       * for an action extends a ForwardConfig declared globally, with both
55       * ForwardConfigs using the same name.
56       */
57      protected ForwardConfig actionBaseConfig = null;
58  
59      /**
60       * An action mapping we'll use within tests.
61       */
62      protected ActionConfig actionConfig = null;
63  
64      // ----------------------------------------------------------- Constructors
65  
66      /**
67       * Construct a new instance of this test case.
68       *
69       * @param name Name of the test case
70       */
71      public TestForwardConfig(String name) {
72          super(name);
73      }
74  
75      // --------------------------------------------------------- Public Methods
76  
77      /**
78       * Set up instance variables required by this test case.
79       */
80      public void setUp() {
81          ModuleConfigFactory factoryObject = ModuleConfigFactory.createFactory();
82  
83          moduleConfig = factoryObject.createModuleConfig("");
84  
85          // Setup the base and sub forwards, with sub extending base
86          baseConfig = new ForwardConfig();
87          baseConfig.setName("baseConfig");
88          baseConfig.setPath("/somePage.jsp");
89  
90          subConfig = new ForwardConfig();
91          subConfig.setName("subConfig");
92          subConfig.setExtends("baseConfig");
93          subConfig.setRedirect(true);
94  
95          actionBaseConfig = new ForwardConfig();
96          actionBaseConfig.setName("baseConfig");
97          actionBaseConfig.setExtends("baseConfig");
98          actionBaseConfig.setModule("/other");
99  
100         // Setup the default action config
101         actionConfig = new ActionConfig();
102         actionConfig.setPath("/index");
103         moduleConfig.addActionConfig(actionConfig);
104 
105         // No forward configs are registered to either module or action configs.
106         // Each test will determine where it needs these configs, if at all.
107     }
108 
109     /**
110      * Return the tests included in this test suite.
111      */
112     public static Test suite() {
113         return (new TestSuite(TestForwardConfig.class));
114     }
115 
116     /**
117      * Tear down instance variables required by this test case.
118      */
119     public void tearDown() {
120         moduleConfig = null;
121         baseConfig = null;
122     }
123 
124     // ------------------------------------------------------- Individual Tests
125 
126     /**
127      * Make sure checkCircularInheritance() works as expected where there is
128      * no inheritance set up.
129      */
130     public void testCheckCircularInheritanceNoExtends() {
131         moduleConfig.addForwardConfig(baseConfig);
132 
133         boolean result =
134             baseConfig.checkCircularInheritance(moduleConfig, null);
135 
136         assertTrue("Incorrect result", !result);
137     }
138 
139     /**
140      * Test checkCircularInheritance() for when there is no circular
141      * inheritance.
142      */
143     public void testCheckCircularInheritanceNoConflicts() {
144         moduleConfig.addForwardConfig(baseConfig);
145         moduleConfig.addForwardConfig(subConfig);
146 
147         boolean result = subConfig.checkCircularInheritance(moduleConfig, null);
148 
149         assertTrue("Incorrect result", !result);
150     }
151 
152     /**
153      * Test checkCircularInheritance() for circular inheritance between global
154      * forwards.
155      */
156     public void testCheckCircularInheritanceBasicGlobal() {
157         moduleConfig.addForwardConfig(subConfig);
158         moduleConfig.addForwardConfig(baseConfig);
159 
160         // set the baseConfig to extend subConfig
161         baseConfig.setExtends("subConfig");
162 
163         boolean result = subConfig.checkCircularInheritance(moduleConfig, null);
164 
165         assertTrue("Circular inheritance not detected.", result);
166     }
167 
168     /**
169      * Test checkCircularInheritance() for circular inheritance between global
170      * forwards.
171      */
172     public void testCheckCircularInheritanceGlobal2Levels() {
173         moduleConfig.addForwardConfig(baseConfig);
174         moduleConfig.addForwardConfig(subConfig);
175 
176         ForwardConfig grand = new ForwardConfig();
177 
178         grand.setName("grandConfig");
179         grand.setExtends("subConfig");
180         moduleConfig.addForwardConfig(grand);
181 
182         // set the baseConfig to extend grandConfig
183         baseConfig.setExtends("grandConfig");
184 
185         boolean result = grand.checkCircularInheritance(moduleConfig, null);
186 
187         assertTrue("Circular inheritance not detected.", result);
188     }
189 
190     /**
191      * Test checkCircularInheritance() for circular inheritance between
192      * forwards in an action.
193      */
194     public void testCheckCircularInheritanceActionForwardsNoConflict() {
195         actionConfig.addForwardConfig(baseConfig);
196         actionConfig.addForwardConfig(subConfig);
197 
198         boolean result =
199             subConfig.checkCircularInheritance(moduleConfig, actionConfig);
200 
201         assertTrue("Incorrect result", !result);
202     }
203 
204     /**
205      * Test checkCircularInheritance() for circular inheritance between
206      * forwards in an action.
207      */
208     public void testCheckCircularInheritanceActionForwardsBasic() {
209         actionConfig.addForwardConfig(baseConfig);
210         actionConfig.addForwardConfig(subConfig);
211 
212         // set base to extend sub
213         baseConfig.setExtends("subConfig");
214 
215         boolean result =
216             subConfig.checkCircularInheritance(moduleConfig, actionConfig);
217 
218         assertTrue("Circular inheritance not detected.", result);
219     }
220 
221     /**
222      * Test checkCircularInheritance() for circular inheritance between a
223      * forward declared in an action and a global forward.
224      */
225     public void testCheckCircularInheritanceActionForwardExtendGlobal() {
226         actionConfig.addForwardConfig(subConfig);
227         moduleConfig.addForwardConfig(baseConfig);
228 
229         boolean result =
230             subConfig.checkCircularInheritance(moduleConfig, actionConfig);
231 
232         assertTrue("Incorrect result", !result);
233     }
234 
235     /**
236      * Test checkCircularInheritance() for circular inheritance between a
237      * forward declared in an action and a global forward and both forwards
238      * have the same name.
239      */
240     public void testCheckCircularInheritanceActionForwardExtendGlobalSameName() {
241         moduleConfig.addForwardConfig(baseConfig);
242         actionConfig.addForwardConfig(actionBaseConfig);
243 
244         boolean result =
245             actionBaseConfig.checkCircularInheritance(moduleConfig, actionConfig);
246 
247         assertTrue("Incorrect result", !result);
248     }
249 
250     /**
251      * Make sure processExtends() throws an error when the config is already
252      * configured.
253      */
254     public void testProcessExtendsConfigured()
255         throws Exception {
256         baseConfig.configured = true;
257         moduleConfig.addForwardConfig(baseConfig);
258 
259         try {
260             baseConfig.processExtends(moduleConfig, null);
261             fail(
262                 "processExtends should not succeed when object is already configured");
263         } catch (IllegalStateException e) {
264             // success
265         }
266     }
267 
268     /**
269      * Test processExtends() when nothing is extended.
270      */
271     public void testProcessExtendsNoExtension()
272         throws Exception {
273         String path = baseConfig.getPath();
274         String module = baseConfig.getModule();
275         String name = baseConfig.getName();
276         String inherit = baseConfig.getExtends();
277         boolean redirect = baseConfig.getRedirect();
278 
279         moduleConfig.addForwardConfig(baseConfig);
280         baseConfig.processExtends(moduleConfig, null);
281 
282         assertEquals("Path shouldn't have changed", path, baseConfig.getPath());
283         assertEquals("Module shouldn't have changed", module,
284             baseConfig.getModule());
285         assertEquals("Name shouldn't have changed", name, baseConfig.getName());
286         assertEquals("Extends shouldn't have changed", inherit,
287             baseConfig.getExtends());
288         assertEquals("Redirect shouldn't have changed", redirect,
289             baseConfig.getRedirect());
290     }
291 
292     /**
293      * Test processExtends() with a basic extension.
294      */
295     public void testProcessExtendsBasicExtension()
296         throws Exception {
297         String baseCount = "10";
298 
299         baseConfig.setProperty("count", baseCount);
300 
301         String baseLabel = "label a";
302 
303         baseConfig.setProperty("label", baseLabel);
304 
305         String path = baseConfig.getPath();
306         String module = baseConfig.getModule();
307 
308         String inherit = subConfig.getExtends();
309         String name = subConfig.getName();
310         boolean redirect = subConfig.getRedirect();
311 
312         String subLabel = "label b";
313 
314         subConfig.setProperty("label", subLabel);
315 
316         moduleConfig.addForwardConfig(baseConfig);
317         moduleConfig.addForwardConfig(subConfig);
318         subConfig.processExtends(moduleConfig, null);
319 
320         assertEquals("Path wasn't inherited", path, subConfig.getPath());
321         assertEquals("Module wasn't inherited", module, subConfig.getModule());
322         assertEquals("Name shouldn't have changed", name, subConfig.getName());
323         assertEquals("Extends shouldn't have changed", inherit,
324             subConfig.getExtends());
325         assertEquals("Redirect shouldn't have changed", redirect,
326             subConfig.getRedirect());
327         assertEquals("Arbitrary config property was not inherited", baseCount,
328             subConfig.getProperty("count"));
329         assertEquals("Overridden config property was not retained", subLabel,
330             subConfig.getProperty("label"));
331     }
332 
333     /**
334      * Test processExtends() with a basic extension between an action config
335      * and a global config.
336      */
337     public void testProcessExtendsBasicGlobalExtension()
338         throws Exception {
339         String path = baseConfig.getPath();
340         String module = baseConfig.getModule();
341 
342         boolean redirect = subConfig.getRedirect();
343         String inherit = subConfig.getExtends();
344         String name = subConfig.getName();
345 
346         moduleConfig.addForwardConfig(baseConfig);
347         actionConfig.addForwardConfig(subConfig);
348         subConfig.processExtends(moduleConfig, actionConfig);
349 
350         assertEquals("Path wasn't inherited", path, subConfig.getPath());
351         assertEquals("Module wasn't inherited", module, subConfig.getModule());
352         assertEquals("Name shouldn't have changed", name, subConfig.getName());
353         assertEquals("Extends shouldn't have changed", inherit,
354             subConfig.getExtends());
355         assertEquals("Redirect shouldn't have changed", redirect,
356             subConfig.getRedirect());
357     }
358 
359     /**
360      * Test processExtends() with an incorrect setup where a global config
361      * attempts to extend an action config.
362      */
363     public void testProcessExtendsGlobalExtendingAction()
364         throws Exception {
365         moduleConfig.addForwardConfig(subConfig);
366         actionConfig.addForwardConfig(baseConfig);
367 
368         try {
369             subConfig.processExtends(moduleConfig, actionConfig);
370             fail(
371                 "Should not find config from actionConfig when *this* is global");
372         } catch (NullPointerException npe) {
373             // succeed
374         }
375     }
376 
377     /**
378      * Test processExtends() with an action config that extends a global
379      * config with the same name.
380      */
381     public void testProcessExtendsSameNames()
382         throws Exception {
383         String path = baseConfig.getPath();
384         boolean redirect = baseConfig.getRedirect();
385 
386         String module = actionBaseConfig.getModule();
387         String inherit = actionBaseConfig.getExtends();
388         String name = actionBaseConfig.getName();
389 
390         moduleConfig.addForwardConfig(baseConfig);
391         actionConfig.addForwardConfig(actionBaseConfig);
392 
393         actionBaseConfig.processExtends(moduleConfig, actionConfig);
394 
395         assertEquals("Path wasn't inherited", path, actionBaseConfig.getPath());
396         assertEquals("Module shouldn't have changed", module,
397             actionBaseConfig.getModule());
398         assertEquals("Name shouldn't have changed", name,
399             actionBaseConfig.getName());
400         assertEquals("Extends shouldn't have changed", inherit,
401             actionBaseConfig.getExtends());
402         assertEquals("Redirect shouldn't have changed", redirect,
403             actionBaseConfig.getRedirect());
404     }
405 
406     /**
407      * Test processExtends() where an action ForwardConfig extends another
408      * ForwardConfig, which in turn extends a global ForwardConfig with the
409      * same name.
410      */
411     public void testProcessExtendsActionExtendsActionExtendsGlobalWithSameName()
412         throws Exception {
413         String path = baseConfig.getPath();
414 
415         String module = actionBaseConfig.getModule();
416 
417         boolean redirect = subConfig.getRedirect();
418         String inherit = subConfig.getExtends();
419         String name = subConfig.getName();
420 
421         moduleConfig.addForwardConfig(baseConfig);
422         actionConfig.addForwardConfig(actionBaseConfig);
423         actionConfig.addForwardConfig(subConfig);
424 
425         subConfig.processExtends(moduleConfig, actionConfig);
426 
427         assertTrue("baseConfig's processExtends() should've been called",
428             baseConfig.extensionProcessed);
429         assertTrue("actionBaseConfig's processExtends() should've been called",
430             actionBaseConfig.extensionProcessed);
431 
432         assertEquals("Path wasn't inherited", path, subConfig.getPath());
433         assertEquals("Module wasn't inherited", module, subConfig.getModule());
434         assertEquals("Name shouldn't have changed", name, subConfig.getName());
435         assertEquals("Extends shouldn't have changed", inherit,
436             subConfig.getExtends());
437         assertEquals("Redirect shouldn't have changed", redirect,
438             subConfig.getRedirect());
439     }
440 }