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.math.BigInteger;
23  import java.sql.Timestamp;
24  import java.util.Date;
25  import java.util.Iterator;
26  import java.util.List;
27  import java.util.Random;
28  
29  import junit.framework.TestCase;
30  
31  import org.org.usurper.TestCommons.NullPropertyException;
32  import org.org.usurper.dummydomain.DummyVOWithVOArrays;
33  import org.org.usurper.dummydomain.DummyVOWithVOCollections;
34  import org.org.usurper.dummydomain.DummyWithChildVO;
35  import org.org.usurper.dummydomain.FcknVO;
36  import org.org.usurper.dummydomain.IImmutableDummyVO;
37  import org.org.usurper.dummydomain.ImmutableDummyVO;
38  import org.org.usurper.dummydomain.ImmutableDummyWithChildVO;
39  import org.org.usurper.dummydomain.ImmutableDummyWithChildVOArray;
40  import org.org.usurper.dummydomain.ImmutableDummyWithChildVOCollections;
41  import org.org.usurper.dummydomain.SonOfDummyWithChildVO;
42  import org.org.usurper.dummydomain.SonOfSonOfDummyWithChildVO;
43  import org.org.usurper.handlers.additional.ListOfValuesSpecificPropertyHandler;
44  import org.org.usurper.handlers.additional.ValueObjectPropertyTypeHandler;
45  import org.org.usurper.handlers.basic.AbstractPropertyTypeHandler;
46  import org.org.usurper.handlers.basic.AbstractSpecificPropertyHandler;
47  import org.org.usurper.model.HandledBeanProperty;
48  import org.org.usurper.model.HandledConstructorArg;
49  import org.org.usurper.model.SpecificPropertyDefinition;
50  
51  /**
52   * Tests former behaviour (with deprecated method calls).
53   * 
54   * @author pagregoire
55   * @since 1.1.0
56   */
57  @SuppressWarnings("deprecation")
58  public class UsurperGeneratorDeprecatedTest extends TestCase {
59  
60      /**
61       * @see junit.framework.TestCase#setUp()
62       */
63      @Override
64      protected void setUp() throws Exception {
65          super.setUp();
66      }
67  
68      public void testGenerateImmutableObject() {
69          // CREATE USURPER GENERATOR
70          UsurperGenerator<ImmutableDummyVO> immutableDummyVOUsurper = new UsurperGenerator<ImmutableDummyVO>(ImmutableDummyVO.class);
71          immutableDummyVOUsurper.registerPropertyTypeHandler(new AbstractPropertyTypeHandler(String.class) {
72  
73              public Object handle(HandledBeanProperty handledBeanProperty) {
74                  return TestCommons.HANDLED_STRING;
75              }
76  
77              public Object handle(HandledConstructorArg handledConstructorArg) {
78                  return TestCommons.HANDLED_STRING;
79              }
80  
81          });
82  
83          // GENERATE USURPER
84          IImmutableDummyVO object = immutableDummyVOUsurper.generateUsurper();
85          assertEquals("The shortest constructor should be used.", ImmutableDummyVO.SHORT_CONTRUCTOR, object.getStringField());
86  
87          // VALIDATE RESULTING OBJECT
88          try {
89              TestCommons.auditVO(object);
90          } catch (NullPropertyException e) {
91              fail(e.getMessage());
92          }
93      }
94  
95      public void testGenerateImmutableWithChildObject() {
96          // CREATE USURPER GENERATOR
97          UsurperGenerator<ImmutableDummyWithChildVO> immutableDummyWithChildVOUsurper = new UsurperGenerator<ImmutableDummyWithChildVO>(ImmutableDummyWithChildVO.class);
98  
99          // REGISTER AN HANDLER FOR SPECIFIC VALUE OBJECTS
100         immutableDummyWithChildVOUsurper.registerPropertyTypeHandler(new ValueObjectPropertyTypeHandler(DummyWithChildVO.class, SonOfDummyWithChildVO.class, SonOfSonOfDummyWithChildVO.class));
101 
102         // GENERATE USURPER
103         ImmutableDummyWithChildVO object = immutableDummyWithChildVOUsurper.generateUsurper();
104 
105         // VALIDATE RESULTING OBJECT
106         try {
107             TestCommons.auditVO(object);
108         } catch (NullPropertyException e) {
109             fail(e.getMessage());
110         }
111     }
112 
113     public void testGenerateImmutableWithChildObjectArray() {
114         // CREATE USURPER GENERATOR
115         UsurperGenerator<ImmutableDummyWithChildVOArray> immutableDummyWithChildVOArrayUsurper = new UsurperGenerator<ImmutableDummyWithChildVOArray>(ImmutableDummyWithChildVOArray.class);
116 
117         // REGISTER AN HANDLER FOR SPECIFIC VALUE OBJECTS
118         immutableDummyWithChildVOArrayUsurper.registerPropertyTypeHandler(new ValueObjectPropertyTypeHandler(DummyWithChildVO.class, SonOfDummyWithChildVO.class, SonOfSonOfDummyWithChildVO.class));
119 
120         // GENERATE USURPER
121         ImmutableDummyWithChildVOArray object = immutableDummyWithChildVOArrayUsurper.generateUsurper();
122 
123         // VALIDATE RESULTING OBJECT
124         try {
125             TestCommons.auditVO(object);
126         } catch (NullPropertyException e) {
127             fail(e.getMessage());
128         }
129     }
130 
131     public void testGenerateImmutableWithChildObjectCollections() {
132         // CREATE USURPER GENERATOR
133         UsurperGenerator<ImmutableDummyWithChildVOCollections> immutableDummyWithChildVOCollectionsUsurper = new UsurperGenerator<ImmutableDummyWithChildVOCollections>(ImmutableDummyWithChildVOCollections.class);
134 
135         // REGISTER AN HANDLER FOR SPECIFIC VALUE OBJECTS
136         immutableDummyWithChildVOCollectionsUsurper.registerPropertyTypeHandler(new ValueObjectPropertyTypeHandler(DummyWithChildVO.class, SonOfDummyWithChildVO.class, SonOfSonOfDummyWithChildVO.class));
137 
138         // GENERATE USURPER
139         ImmutableDummyWithChildVOCollections object = immutableDummyWithChildVOCollectionsUsurper.generateUsurper();
140 
141         // VALIDATE RESULTING OBJECT
142         try {
143             TestCommons.auditVO(object);
144         } catch (NullPropertyException e) {
145             fail(e.getMessage());
146         }
147     }
148 
149     public void testGenerateImmutableObjectWithChosenConstructor() {
150         // CREATE USURPER GENERATOR
151         UsurperGenerator<ImmutableDummyVO> immutableDummyVOUsurper = new UsurperGenerator<ImmutableDummyVO>(ImmutableDummyVO.class);
152         immutableDummyVOUsurper.registerPropertyTypeHandler(new AbstractPropertyTypeHandler(String.class) {
153 
154             public Object handle(HandledBeanProperty handledBeanProperty) {
155                 return TestCommons.HANDLED_STRING;
156             }
157 
158             public Object handle(HandledConstructorArg handledConstructorArg) {
159                 return TestCommons.HANDLED_STRING;
160             }
161 
162         });
163         immutableDummyVOUsurper.useConstructor(Integer.class, Float.class, Double.class, String.class, Date.class, Long.class, Short.class, Boolean.class, int.class, short.class, long.class, boolean.class, byte.class, char.class, float.class, double.class, Timestamp.class, java.sql.Date.class);
164         // GENERATE USURPER
165         IImmutableDummyVO object = immutableDummyVOUsurper.generateUsurper();
166         assertNotSame("The shortest constructor should not be used.", ImmutableDummyVO.SHORT_CONTRUCTOR, object.getStringField());
167         assertEquals("The longest constructor should be used.", TestCommons.HANDLED_STRING, object.getStringField());
168 
169         // VALIDATE RESULTING OBJECT
170         try {
171             TestCommons.auditVO(object);
172         } catch (NullPropertyException e) {
173             fail(e.getMessage());
174         }
175     }
176 
177     public void testGenerateObjectWithChilds() {
178         // CREATE USURPER GENERATOR
179         UsurperGenerator<DummyWithChildVO> dummyVOUsurper = new UsurperGenerator<DummyWithChildVO>(DummyWithChildVO.class);
180 
181         // REGISTER AN HANDLER FOR SPECIFIC VALUE OBJECTS
182         ValueObjectPropertyTypeHandler valueObjectFieldTypeHandler = new ValueObjectPropertyTypeHandler(SonOfDummyWithChildVO.class, SonOfSonOfDummyWithChildVO.class);
183         dummyVOUsurper.registerPropertyTypeHandler(valueObjectFieldTypeHandler);
184 
185         // GENERATE USURPER
186         DummyWithChildVO object = dummyVOUsurper.generateUsurper();
187 
188         // VALIDATE RESULTING OBJECT
189         try {
190             TestCommons.auditVO(object);
191         } catch (NullPropertyException e) {
192             fail(e.getMessage());
193         }
194     }
195 
196     public void testGenerateObjectWithVOCollectionChilds() {
197         // CREATE USURPER GENERATOR
198         UsurperGenerator<DummyVOWithVOCollections> dummyVOUsurper = new UsurperGenerator<DummyVOWithVOCollections>(DummyVOWithVOCollections.class);
199 
200         // REGISTER AN HANDLER FOR SPECIFIC VALUE OBJECTS
201         dummyVOUsurper.registerPropertyTypeHandler(new ValueObjectPropertyTypeHandler(SonOfDummyWithChildVO.class, SonOfSonOfDummyWithChildVO.class));
202 
203         // GENERATE USURPER
204         DummyVOWithVOCollections object = dummyVOUsurper.generateUsurper();
205 
206         // VALIDATE RESULTING OBJECT
207         try {
208             TestCommons.auditVO(object);
209         } catch (NullPropertyException e) {
210             fail(e.getMessage());
211         }
212     }
213 
214     public void testGenerateObjectWithVOArrayChilds() {
215         // CREATE USURPER GENERATOR
216         UsurperGenerator<DummyVOWithVOArrays> dummyVOUsurper = new UsurperGenerator<DummyVOWithVOArrays>(DummyVOWithVOArrays.class);
217 
218         // REGISTER AN HANDLER FOR SPECIFIC VALUE OBJECTS
219         dummyVOUsurper.registerPropertyTypeHandler(new ValueObjectPropertyTypeHandler(SonOfDummyWithChildVO.class, SonOfSonOfDummyWithChildVO.class));
220 
221         // GENERATE USURPER
222         DummyVOWithVOArrays object = dummyVOUsurper.generateUsurper();
223 
224         // VALIDATE RESULTING OBJECT
225         try {
226             TestCommons.auditVO(object);
227         } catch (NullPropertyException e) {
228             fail(e.getMessage());
229         }
230     }
231 
232     public void testGenerateObjectWithListOfValuesSpecificPropertyHandler() {
233         // CREATE USURPER GENERATOR
234         UsurperGenerator<FcknVO> fcknVOUsurper = new UsurperGenerator<FcknVO>(FcknVO.class);
235 
236         // REGISTER CUSTOM SPECIFIC FIELD HANDLERS
237         fcknVOUsurper.registerSpecificPropertyHandler(new ListOfValuesSpecificPropertyHandler(new SpecificPropertyDefinition(FcknVO.class, "bigIntField"), TestCommons.BIG_INTEGER_VALUES_LIST));
238         fcknVOUsurper.registerSpecificPropertyHandler(new ListOfValuesSpecificPropertyHandler(new SpecificPropertyDefinition(FcknVO.class, "bigIntField2"), TestCommons.BIG_INTEGER_VALUES_LIST));
239 
240         // GENERATE USURPER
241         List<FcknVO> collection = fcknVOUsurper.generateUsurperList(6);
242 
243         Iterator<BigInteger> it = TestCommons.BIG_INTEGER_VALUES_LIST.iterator();
244         // VALIDATE RESULTING OBJECT
245         for (FcknVO fcknVO : collection) {
246             try {
247                 TestCommons.auditVO(fcknVO);
248             } catch (NullPropertyException e) {
249                 fail(e.getMessage());
250             }
251             if (!it.hasNext()) {
252                 it = TestCommons.BIG_INTEGER_VALUES_LIST.iterator();
253             }
254             BigInteger nextValue = it.next();
255             assertEquals("the specificFieldHandler should put the <" + nextValue + "> value for the <bigIntField> field", nextValue, fcknVO.getBigIntField());
256             assertEquals("the specificFieldHandler should put the <" + nextValue + "> value for the <bigIntField2> field", nextValue, fcknVO.getBigIntField2());
257         }
258     }
259 
260     public void testGenerateObjectWithSpecificPropertyHandler() {
261         // CREATE USURPER GENERATOR
262         UsurperGenerator<FcknVO> fcknVOUsurper = new UsurperGenerator<FcknVO>(FcknVO.class);
263 
264         // REGISTER CUSTOM SPECIFIC FIELD HANDLERS
265         fcknVOUsurper.registerSpecificPropertyHandler(new AbstractSpecificPropertyHandler(new SpecificPropertyDefinition(FcknVO.class, "bigIntField")) {
266             public Object handle(HandledBeanProperty handledBeanProperty) {
267                 return TestCommons.BIG_INTEGER_VALUE;
268             }
269 
270             public Object handle(HandledConstructorArg handledConstructorArg) {
271                 return TestCommons.BIG_INTEGER_VALUE;
272             }
273         });
274         fcknVOUsurper.registerSpecificPropertyHandler(new AbstractSpecificPropertyHandler(new SpecificPropertyDefinition(FcknVO.class, "bigIntField2")) {
275             public Object handle(HandledBeanProperty handledBeanProperty) {
276                 return TestCommons.BIG_INTEGER_VALUE;
277             }
278 
279             public Object handle(HandledConstructorArg handledConstructorArg) {
280                 return TestCommons.BIG_INTEGER_VALUE;
281             }
282         });
283 
284         // GENERATE USURPER
285         FcknVO object = fcknVOUsurper.generateUsurper();
286 
287         // VALIDATE RESULTING OBJECT
288         assertEquals("the specificFieldHandler should put a default value for the field", TestCommons.BIG_INTEGER_VALUE, ((FcknVO) object).getBigIntField());
289         assertEquals("the specificFieldHandler should put a default value for the field", TestCommons.BIG_INTEGER_VALUE, ((FcknVO) object).getBigIntField2());
290         try {
291             TestCommons.auditVO(object);
292         } catch (NullPropertyException e) {
293             fail(e.getMessage());
294         }
295     }
296 
297     public void testGenerateObjectWithPropertyTypeHandler() {
298         // CREATE USURPER GENERATOR
299         UsurperGenerator<FcknVO> fcknVOUsurper = new UsurperGenerator<FcknVO>(FcknVO.class);
300 
301         // REGISTER CUSTOM TYPE HANDLER
302         fcknVOUsurper.registerPropertyTypeHandler(new AbstractPropertyTypeHandler(BigInteger.class) {
303             public Object handle(HandledBeanProperty handledBeanProperty) {
304                 return new BigInteger(24, new Random());
305             }
306 
307             public Object handle(HandledConstructorArg handledConstructorArg) {
308                 return new BigInteger(24, new Random());
309             }
310         });
311 
312         // GENERATE USURPER
313         FcknVO object3 = fcknVOUsurper.generateUsurper();
314 
315         // VALIDATE RESULTING OBJECT
316         try {
317             TestCommons.auditVO(object3);
318         } catch (NullPropertyException e) {
319             fail(e.getMessage());
320         }
321     }
322 
323 }