1   /*
2    ORG Usurper is a random value object generator library 
3    Copyright (C) 2007  Pierre-Antoine Grégoire
4    
5    This library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9    
10   This library is distributed in the hope that it will be useful,
11   but WITHOUT ANY WARRANTY; without even the implied warranty of
12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13   Lesser General Public License for more details.
14   
15   You should have received a copy of the GNU Lesser General Public
16   License along with this library; if not, write to the Free Software
17   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18   */
19  
20  package org.org.usurper;
21  
22  import java.util.List;
23  import java.util.Map;
24  import java.util.Set;
25  
26  import junit.framework.TestCase;
27  
28  import org.org.usurper.TestCommons.BadSetupException;
29  import org.org.usurper.TestCommons.NullPropertyException;
30  import org.org.usurper.dummydomain.DummyService;
31  import org.org.usurper.dummydomain.DummyVO;
32  import org.org.usurper.dummydomain.IDummyDAO;
33  import org.org.usurper.dummydomain.IOtherDummyDAO;
34  import org.org.usurper.dummydomain.ImmutableDummyVO;
35  import org.org.usurper.dummydomain.OtherDummyVO;
36  import org.org.usurper.setup.IUsurperGeneratorSetup;
37  import org.org.usurper.setup.constants.OnMissingHandlers;
38  import org.org.usurper.setup.constants.PropertyWritingMechanism;
39  import org.org.usurper.springframework.UsurperFactoryBean;
40  import org.org.usurper.springframework.UsurperGeneratorSetupFactoryBean;
41  import org.org.usurper.springframework.UsurperListFactoryBean;
42  import org.org.usurper.springframework.UsurperMapFactoryBean;
43  import org.org.usurper.springframework.UsurperSetFactoryBean;
44  import org.org.usurper.springframework.UsurperSpringConstants;
45  import org.springframework.context.ApplicationContext;
46  import org.springframework.context.support.ClassPathXmlApplicationContext;
47  
48  /**
49   * @author pagregoire
50   */
51  public class UsurperSpringTest extends TestCase {
52  
53      /**
54       * @see junit.framework.TestCase#setUp()
55       */
56      @Override
57      protected void setUp() throws Exception {
58          super.setUp();
59      }
60  
61      public void testGenerateObject() throws Exception {
62          // CREATE USURPER GENERATOR
63          UsurperFactoryBean usurperFactoryBean = new UsurperFactoryBean();
64          usurperFactoryBean.setUsurpedClassName(DummyVO.class.getName());
65          usurperFactoryBean.afterPropertiesSet();
66          // GENERATE USURPER
67          DummyVO object = (DummyVO) usurperFactoryBean.getObject();
68  
69          // VALIDATE RESULTING OBJECT
70          try {
71              TestCommons.auditVO(object);
72          } catch (NullPropertyException e) {
73              fail(e.getMessage());
74          }
75      }
76  
77      @SuppressWarnings("unchecked")
78      public void testGenerateList() throws Exception {
79          final int listSize = 15;
80          // CREATE USURPER GENERATOR
81          UsurperListFactoryBean usurperListFactoryBean = new UsurperListFactoryBean();
82          usurperListFactoryBean.setUsurpedClassName(DummyVO.class.getName());
83          usurperListFactoryBean.setCount(listSize);
84          usurperListFactoryBean.afterPropertiesSet();
85          // GENERATE USURPER
86          List list = (List) usurperListFactoryBean.getObject();
87          assertTrue("Generated List's size should be " + listSize, list.size() == listSize);
88          // VALIDATE RESULTING OBJECT
89          try {
90              for (Object object : list) {
91                  TestCommons.auditVO(object);
92              }
93          } catch (NullPropertyException e) {
94              fail(e.getMessage());
95          }
96      }
97  
98      @SuppressWarnings("unchecked")
99      public void testGenerateSet() throws Exception {
100         final int setSize = 15;
101         // CREATE USURPER GENERATOR
102         UsurperSetFactoryBean usurperSetFactoryBean = new UsurperSetFactoryBean();
103         usurperSetFactoryBean.setUsurpedClassName(DummyVO.class.getName());
104         usurperSetFactoryBean.setCount(setSize);
105         usurperSetFactoryBean.afterPropertiesSet();
106         // GENERATE USURPER
107         Set set = (Set) usurperSetFactoryBean.getObject();
108         assertTrue("Generated Set's size should be " + setSize, set.size() == setSize);
109         // VALIDATE RESULTING OBJECT
110         try {
111             for (Object object : set) {
112                 TestCommons.auditVO(object);
113             }
114         } catch (NullPropertyException e) {
115             fail(e.getMessage());
116         }
117     }
118 
119     @SuppressWarnings("unchecked")
120     public void testGenerateMap() throws Exception {
121         final int mapSize = 15;
122         // CREATE USURPER GENERATOR
123         UsurperMapFactoryBean usurperMapFactoryBean = new UsurperMapFactoryBean();
124         usurperMapFactoryBean.setUsurpedKeyClassName(DummyVO.class.getName());
125         usurperMapFactoryBean.setUsurpedValueClassName(OtherDummyVO.class.getName());
126         usurperMapFactoryBean.setCount(mapSize);
127         usurperMapFactoryBean.afterPropertiesSet();
128         // GENERATE USURPER
129         Map map = (Map) usurperMapFactoryBean.getObject();
130         assertTrue("Generated Map's size should be " + mapSize, map.size() == mapSize);
131         // VALIDATE RESULTING OBJECT
132         try {
133             Set keys = map.keySet();
134             for (Object key : keys) {
135                 TestCommons.auditVO(key);
136                 TestCommons.auditVO(map.get(key));
137             }
138         } catch (NullPropertyException e) {
139             fail(e.getMessage());
140         }
141     }
142 
143     public void testGenerateObjectWithNamespaceHandler() throws Exception {
144         // CREATE USURPER GENERATOR through Spring namespace
145         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-namespace-onebean.xml");
146         // RETRIEVE USURPER
147         DummyVO object = (DummyVO) applicationContext.getBean("DummyVO");
148 
149         // VALIDATE RESULTING OBJECT
150         try {
151             TestCommons.auditVO(object);
152         } catch (NullPropertyException e) {
153             fail(e.getMessage());
154         }
155 
156         // RETRIEVE USURPER
157         object = ((DummyService) applicationContext.getBean("DummyService")).getDummyVO();
158 
159         // VALIDATE RESULTING OBJECT
160         try {
161             TestCommons.auditVO(object);
162         } catch (NullPropertyException e) {
163             fail(e.getMessage());
164         }
165     }
166 
167     @SuppressWarnings("unchecked")
168     public void testGenerateListWithNamespaceHandler() throws Exception {
169         final int listSize = 15;
170         // CREATE USURPER GENERATOR through Spring namespace
171         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-namespace-listofbeans.xml");
172         // RETRIEVE USURPER
173         List list = (List) applicationContext.getBean("DummyVOs");
174 
175         assertTrue("Generated List's size should be " + listSize, list.size() == listSize);
176         // VALIDATE RESULTING OBJECT
177         try {
178             for (Object object : list) {
179                 TestCommons.auditVO(object);
180             }
181         } catch (NullPropertyException e) {
182             fail(e.getMessage());
183         }
184     }
185 
186     @SuppressWarnings("unchecked")
187     public void testGenerateSetWithNamespaceHandler() throws Exception {
188         final int setSize = 15;
189         // CREATE USURPER GENERATOR through Spring namespace
190         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-namespace-setofbeans.xml");
191         // RETRIEVE USURPER
192         Set set = (Set) applicationContext.getBean("DummyVOs");
193         assertTrue("Generated Set's size should be " + setSize, set.size() == setSize);
194         // VALIDATE RESULTING OBJECT
195         try {
196             for (Object object : set) {
197                 TestCommons.auditVO(object);
198             }
199         } catch (NullPropertyException e) {
200             fail(e.getMessage());
201         }
202     }
203 
204     @SuppressWarnings("unchecked")
205     public void testGenerateMapWithNamespaceHandler() throws Exception {
206         final int mapSize = 15;
207         // CREATE USURPER GENERATOR through Spring namespace
208         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-namespace-mapofbeans.xml");
209         // RETRIEVE USURPER
210         Map map = (Map) applicationContext.getBean("DummyVOs");
211         assertTrue("Generated Map's size should be " + mapSize, map.size() == mapSize);
212         // VALIDATE RESULTING OBJECT
213         try {
214             Set keys = map.keySet();
215             for (Object key : keys) {
216                 TestCommons.auditVO(key);
217                 TestCommons.auditVO(map.get(key));
218             }
219         } catch (NullPropertyException e) {
220             fail(e.getMessage());
221         }
222     }
223 
224     @SuppressWarnings("unchecked")
225     public void testMethodInterceptor() throws Exception {
226         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-aop.xml");
227         IDummyDAO dummyDAO = (IDummyDAO) applicationContext.getBean("DummyDAO");
228 
229         // RETRIEVE USURPER
230         DummyVO dummyVO = dummyDAO.getVO("whatever, this is not used");
231 
232         // VALIDATE RESULTING OBJECT
233         try {
234             TestCommons.auditVO(dummyVO);
235         } catch (NullPropertyException e) {
236             fail(e.getMessage());
237         }
238 
239         // RETRIEVE USURPER
240         List list = dummyDAO.getVOList("whatever, this is not used");
241 
242         assertTrue("Generated List's size should be " + UsurperSpringConstants.DEFAULT_ENTRIES_COUNT, list.size() == UsurperSpringConstants.DEFAULT_ENTRIES_COUNT);
243         // VALIDATE RESULTING OBJECT
244         try {
245             for (Object object : list) {
246                 TestCommons.auditVO(object);
247             }
248         } catch (NullPropertyException e) {
249             fail(e.getMessage());
250         }
251 
252         // RETRIEVE USURPER
253         Set set = dummyDAO.getVOSet("whatever, this is not used");
254         assertTrue("Generated Set's size should be " + UsurperSpringConstants.DEFAULT_ENTRIES_COUNT, set.size() == UsurperSpringConstants.DEFAULT_ENTRIES_COUNT);
255         // VALIDATE RESULTING OBJECT
256         try {
257             for (Object object : set) {
258                 TestCommons.auditVO(object);
259             }
260         } catch (NullPropertyException e) {
261             fail(e.getMessage());
262         }
263 
264         // RETRIEVE USURPER
265         Map map = dummyDAO.getVOMap("whatever, this is not used");
266         assertTrue("Generated Map's size should be " + UsurperSpringConstants.DEFAULT_ENTRIES_COUNT, map.size() == UsurperSpringConstants.DEFAULT_ENTRIES_COUNT);
267         // VALIDATE RESULTING OBJECT
268         try {
269             Set keys = map.keySet();
270             for (Object key : keys) {
271                 TestCommons.auditVO(key);
272                 TestCommons.auditVO(map.get(key));
273             }
274         } catch (NullPropertyException e) {
275             fail(e.getMessage());
276         }
277     }
278 
279     @SuppressWarnings("unchecked")
280     public void testMethodInterceptorWithNamespaceHandler() throws Exception {
281         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-namespace-aop.xml");
282         IDummyDAO dummyDAO = (IDummyDAO) applicationContext.getBean("DummyDAO");
283 
284         // RETRIEVE USURPER
285         DummyVO dummyVO = dummyDAO.getVO("whatever, this is not used");
286 
287         // VALIDATE RESULTING OBJECT
288         try {
289             TestCommons.auditVO(dummyVO);
290         } catch (NullPropertyException e) {
291             fail(e.getMessage());
292         }
293 
294         // RETRIEVE USURPER
295         List list = dummyDAO.getVOList("whatever, this is not used");
296 
297         assertTrue("Generated List's size should be " + UsurperSpringConstants.DEFAULT_ENTRIES_COUNT, list.size() == UsurperSpringConstants.DEFAULT_ENTRIES_COUNT);
298         // VALIDATE RESULTING OBJECT
299         try {
300             for (Object object : list) {
301                 TestCommons.auditVO(object);
302             }
303         } catch (NullPropertyException e) {
304             fail(e.getMessage());
305         }
306 
307         // RETRIEVE USURPER
308         Set set = dummyDAO.getVOSet("whatever, this is not used");
309         assertTrue("Generated Set's size should be " + UsurperSpringConstants.DEFAULT_ENTRIES_COUNT, set.size() == UsurperSpringConstants.DEFAULT_ENTRIES_COUNT);
310         // VALIDATE RESULTING OBJECT
311         try {
312             for (Object object : set) {
313                 TestCommons.auditVO(object);
314             }
315         } catch (NullPropertyException e) {
316             fail(e.getMessage());
317         }
318 
319         // RETRIEVE USURPER
320         Map map = dummyDAO.getVOMap("whatever, this is not used");
321         assertTrue("Generated Map's size should be " + UsurperSpringConstants.DEFAULT_ENTRIES_COUNT, map.size() == UsurperSpringConstants.DEFAULT_ENTRIES_COUNT);
322         // VALIDATE RESULTING OBJECT
323         try {
324             Set keys = map.keySet();
325             for (Object key : keys) {
326                 TestCommons.auditVO(key);
327                 TestCommons.auditVO(map.get(key));
328             }
329         } catch (NullPropertyException e) {
330             fail(e.getMessage());
331         }
332     }
333 
334     @SuppressWarnings("unchecked")
335     public void testMethodInterceptorWithNamespaceHandlerAndImmutables() throws Exception {
336         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-namespace-aop-immutable.xml");
337         IOtherDummyDAO dummyDAO = (IOtherDummyDAO) applicationContext.getBean("OtherDummyDAO");
338 
339         // RETRIEVE USURPER
340         ImmutableDummyVO dummyVO = dummyDAO.getVO("whatever, this is not used");
341 
342         // VALIDATE RESULTING OBJECT
343         try {
344             TestCommons.auditVO(dummyVO);
345         } catch (NullPropertyException e) {
346             fail(e.getMessage());
347         }
348 
349         // RETRIEVE USURPER
350         List list = dummyDAO.getVOList("whatever, this is not used");
351 
352         assertTrue("Generated List's size should be " + UsurperSpringConstants.DEFAULT_ENTRIES_COUNT, list.size() == UsurperSpringConstants.DEFAULT_ENTRIES_COUNT);
353         // VALIDATE RESULTING OBJECT
354         try {
355             for (Object object : list) {
356                 TestCommons.auditVO(object);
357             }
358         } catch (NullPropertyException e) {
359             fail(e.getMessage());
360         }
361 
362         // RETRIEVE USURPER
363         Set set = dummyDAO.getVOSet("whatever, this is not used");
364         assertTrue("Generated Set's size should be " + UsurperSpringConstants.DEFAULT_ENTRIES_COUNT, set.size() == UsurperSpringConstants.DEFAULT_ENTRIES_COUNT);
365         // VALIDATE RESULTING OBJECT
366         try {
367             for (Object object : set) {
368                 TestCommons.auditVO(object);
369             }
370         } catch (NullPropertyException e) {
371             fail(e.getMessage());
372         }
373 
374         // RETRIEVE USURPER
375         Map map = dummyDAO.getVOMap("whatever, this is not used");
376         assertTrue("Generated Map's size should be " + UsurperSpringConstants.DEFAULT_ENTRIES_COUNT, map.size() == UsurperSpringConstants.DEFAULT_ENTRIES_COUNT);
377         // VALIDATE RESULTING OBJECT
378         try {
379             Set keys = map.keySet();
380             for (Object key : keys) {
381                 TestCommons.auditVO(key);
382                 TestCommons.auditVO(map.get(key));
383             }
384         } catch (NullPropertyException e) {
385             fail(e.getMessage());
386         }
387     }
388 
389     @SuppressWarnings("unchecked")
390     public void testGenerateSetup() throws Exception {
391         UsurperGeneratorSetupFactoryBean usurperGeneratorSetupFactoryBean = new UsurperGeneratorSetupFactoryBean();
392         usurperGeneratorSetupFactoryBean.setArrayHandler(TestCommons.ARRAY_HANDLER);
393         usurperGeneratorSetupFactoryBean.setEnumHandler(TestCommons.ENUM_HANDLER);
394         usurperGeneratorSetupFactoryBean.setCountCallback(TestCommons.DUMMY_COLLECTION_COUNT_CALLBACK);
395         usurperGeneratorSetupFactoryBean.onMissingHandlers(OnMissingHandlers.SKIP);
396         usurperGeneratorSetupFactoryBean.usePropertyWritingMechanism(PropertyWritingMechanism.USE_SETTERS);
397         usurperGeneratorSetupFactoryBean.setPropertyTypeHandlers(TestCommons.PROPERTY_TYPE_HANDLERS_SET);
398         usurperGeneratorSetupFactoryBean.setSpecificPropertyHandlers(TestCommons.SPECIFIC_PROPERTY_HANDLERS_SET);
399         usurperGeneratorSetupFactoryBean.afterPropertiesSet();
400 
401         IUsurperGeneratorSetup usurperGeneratorSetup = (IUsurperGeneratorSetup) usurperGeneratorSetupFactoryBean.getObject();
402         try {
403             TestCommons.auditSetup(usurperGeneratorSetup);
404         } catch (BadSetupException e) {
405             fail(e.getMessage());
406         }
407 
408         UsurperGeneratorSetupFactoryBean usurperGeneratorSetupFactoryBean2 = new UsurperGeneratorSetupFactoryBean();
409         usurperGeneratorSetupFactoryBean2.setParentSetup(usurperGeneratorSetup);
410         usurperGeneratorSetupFactoryBean2.afterPropertiesSet();
411 
412         IUsurperGeneratorSetup usurperGeneratorSetup2 = (IUsurperGeneratorSetup) usurperGeneratorSetupFactoryBean2.getObject();
413         try {
414             TestCommons.auditSetup(usurperGeneratorSetup2);
415         } catch (BadSetupException e) {
416             fail(e.getMessage());
417         }
418     }
419 
420     @SuppressWarnings("unchecked")
421     public void testGenerateSetupWithXMLConfig() throws Exception {
422         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-setup.xml");
423         IUsurperGeneratorSetup usurperGeneratorSetup = (IUsurperGeneratorSetup) applicationContext.getBean("usurperGeneratorSetupClassic");
424         try {
425             TestCommons.auditSetup(usurperGeneratorSetup);
426         } catch (BadSetupException e) {
427             fail(e.getMessage());
428         }
429 
430         IUsurperGeneratorSetup usurperGeneratorSetup2 = (IUsurperGeneratorSetup) applicationContext.getBean("usurperGeneratorSetupClassic2");
431         try {
432             TestCommons.auditSetup(usurperGeneratorSetup2);
433         } catch (BadSetupException e) {
434             fail(e.getMessage());
435         }
436 
437     }
438 
439     @SuppressWarnings("unchecked")
440     public void testGenerateSetupWithNamespaceHandler() throws Exception {
441         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-namespace-setup.xml");
442         IUsurperGeneratorSetup usurperGeneratorSetup = (IUsurperGeneratorSetup) applicationContext.getBean("usurperGeneratorSetupNamespace");
443         try {
444             TestCommons.auditSetup(usurperGeneratorSetup);
445         } catch (BadSetupException e) {
446             fail(e.getMessage());
447         }
448         IUsurperGeneratorSetup usurperGeneratorSetup2 = (IUsurperGeneratorSetup) applicationContext.getBean("usurperGeneratorSetupNamespace2");
449         try {
450             TestCommons.auditSetup(usurperGeneratorSetup2);
451         } catch (BadSetupException e) {
452             fail(e.getMessage());
453         }
454 
455     }
456 }