1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */ 
17  
18  
19  package org.apache.commons.beanutils;
20  
21  
22  import java.math.BigDecimal;
23  import java.util.Iterator;
24  
25  import junit.framework.TestCase;
26  import junit.framework.Test;
27  import junit.framework.TestSuite;
28  
29  
30  /***
31   * Test accessing ResultSets via DynaBeans.
32   *
33   * @author Craig R. McClanahan
34   * @version $Revision: 556221 $ $Date: 2007-07-14 05:19:21 +0100 (Sat, 14 Jul 2007) $
35   */
36  
37  public class DynaResultSetTestCase extends TestCase {
38  
39  
40      // ----------------------------------------------------- Instance Variables
41  
42  
43      /***
44       * The mock result set DynaClass to be tested.
45       */
46      protected ResultSetDynaClass dynaClass = null;
47  
48  
49      /***
50       * Names of the columns for this test.  Must match the order they are
51       * defined in {@link TestResultSetMetaData}, and must be all lower case.
52       */
53      protected String columns[] =
54      { "bigdecimalproperty", "booleanproperty",
55        "byteproperty", "dateproperty",
56        "doubleproperty", "floatproperty",
57        "intproperty", "longproperty",
58        "nullproperty", "shortproperty",
59        "stringproperty", "timeproperty",
60        "timestampproperty" };
61  
62  
63      // ----------------------------------------------------------- Constructors
64  
65  
66      /***
67       * Construct a new instance of this test case.
68       *
69       * @param name Name of the test case
70       */
71      public DynaResultSetTestCase(String name) {
72  
73          super(name);
74  
75      }
76  
77  
78      // --------------------------------------------------- Overall Test Methods
79  
80  
81      /***
82       * Set up instance variables required by this test case.
83       */
84      public void setUp() throws Exception {
85  
86          dynaClass = new ResultSetDynaClass(TestResultSet.createProxy());
87  
88      }
89  
90  
91      /***
92       * Return the tests included in this test suite.
93       */
94      public static Test suite() {
95  
96          return (new TestSuite(DynaResultSetTestCase.class));
97  
98      }
99  
100 
101     /***
102      * Tear down instance variables required by this test case.
103      */
104     public void tearDown() {
105 
106         dynaClass = null;
107 
108     }
109 
110 
111 
112     // ------------------------------------------------ Individual Test Methods
113 
114 
115     public void testGetName() {
116 
117         assertEquals("DynaClass name",
118                      "org.apache.commons.beanutils.ResultSetDynaClass",
119                      dynaClass.getName());
120 
121 
122     }
123 
124 
125     public void testGetDynaProperty() {
126 
127         // Invalid argument test
128         try {
129             dynaClass.getDynaProperty(null);
130             fail("Did not throw IllegaArgumentException");
131         } catch (IllegalArgumentException e) {
132             // Expected result
133         }
134 
135         // Negative test
136         DynaProperty dynaProp = dynaClass.getDynaProperty("unknownProperty");
137         assertTrue("unknown property returns null",
138                    (dynaProp == null));
139 
140         // Positive test
141         dynaProp = dynaClass.getDynaProperty("stringproperty");
142         assertNotNull("string property exists", dynaProp);
143         assertEquals("string property name", "stringproperty",
144                      dynaProp.getName());
145         assertEquals("string property class", String.class,
146                      dynaProp.getType());
147 
148     }
149 
150 
151     public void testGetDynaProperties() {
152 
153         DynaProperty dynaProps[] = dynaClass.getDynaProperties();
154         assertNotNull("dynaProps exists", dynaProps);
155         assertEquals("dynaProps length", columns.length, dynaProps.length);
156         for (int i = 0; i < columns.length; i++) {
157             assertEquals("Property " + columns[i],
158                          columns[i], dynaProps[i].getName());
159         }
160 
161     }
162 
163 
164     public void testNewInstance() {
165 
166         try {
167             dynaClass.newInstance();
168             fail("Did not throw UnsupportedOperationException()");
169         } catch (UnsupportedOperationException e) {
170             // Expected result
171         } catch (Exception e) {
172             fail("Threw exception " + e);
173         }
174 
175     }
176 
177 
178     public void testIteratorCount() {
179 
180         Iterator rows = dynaClass.iterator();
181         assertNotNull("iterator exists", rows);
182         int n = 0;
183         while (rows.hasNext()) {
184             rows.next();
185             n++;
186             if (n > 10) {
187                 fail("Returned too many rows");
188             }
189         }
190         assertEquals("iterator rows", 5, n);
191 
192     }
193 
194 
195     public void testIteratorResults() {
196 
197         // Grab the third row
198         Iterator rows = dynaClass.iterator();
199         rows.next();
200         rows.next();
201         DynaBean row = (DynaBean) rows.next();
202 
203         // Invalid argument test
204         try {
205             row.get("unknownProperty");
206             fail("Did not throw IllegalArgumentException");
207         } catch (IllegalArgumentException e) {
208             // Expected result
209         }
210 
211         // Verify property values
212 
213         Object bigDecimalProperty = row.get("bigdecimalproperty");
214         assertNotNull("bigDecimalProperty exists", bigDecimalProperty);
215         assertTrue("bigDecimalProperty type",
216                    bigDecimalProperty instanceof BigDecimal);
217         assertEquals("bigDecimalProperty value",
218                      123.45,
219                      ((BigDecimal) bigDecimalProperty).doubleValue(),
220                      0.005);
221 
222         Object intProperty = row.get("intproperty");
223         assertNotNull("intProperty exists", intProperty);
224         assertTrue("intProperty type",
225                    intProperty instanceof Integer);
226         assertEquals("intProperty value",
227                      103,
228                      ((Integer) intProperty).intValue());
229 
230         Object nullProperty = row.get("nullproperty");
231         assertNull("nullProperty null", nullProperty);
232 
233         Object stringProperty = row.get("stringproperty");
234         assertNotNull("stringProperty exists", stringProperty);
235         assertTrue("stringProperty type",
236                    stringProperty instanceof String);
237         assertEquals("stringProperty value",
238                      "This is a string",
239                      (String) stringProperty);
240 
241 
242     }
243 
244 
245     /***
246      * Test normal case column names (i.e. not converted to lower case)
247      */
248     public void testIteratorResultsNormalCase() {
249         ResultSetDynaClass dynaClass = null;
250         try {
251             dynaClass = new ResultSetDynaClass(TestResultSet.createProxy(), false);
252         } catch (Exception e) {
253             fail("Error creating ResultSetDynaClass: " + e);
254         }
255 
256         // Grab the third row
257         Iterator rows = dynaClass.iterator();
258         rows.next();
259         rows.next();
260         DynaBean row = (DynaBean) rows.next();
261 
262         // Invalid argument test
263         try {
264             row.get("unknownProperty");
265             fail("Did not throw IllegalArgumentException");
266         } catch (IllegalArgumentException e) {
267             // Expected result
268         }
269 
270         // Verify property values
271 
272         Object bigDecimalProperty = row.get("bigDecimalProperty");
273         assertNotNull("bigDecimalProperty exists", bigDecimalProperty);
274         assertTrue("bigDecimalProperty type",
275                    bigDecimalProperty instanceof BigDecimal);
276         assertEquals("bigDecimalProperty value",
277                      123.45,
278                      ((BigDecimal) bigDecimalProperty).doubleValue(),
279                      0.005);
280 
281         Object intProperty = row.get("intProperty");
282         assertNotNull("intProperty exists", intProperty);
283         assertTrue("intProperty type",
284                    intProperty instanceof Integer);
285         assertEquals("intProperty value",
286                      103,
287                      ((Integer) intProperty).intValue());
288 
289         Object nullProperty = row.get("nullProperty");
290         assertNull("nullProperty null", nullProperty);
291 
292         Object stringProperty = row.get("stringProperty");
293         assertNotNull("stringProperty exists", stringProperty);
294         assertTrue("stringProperty type",
295                    stringProperty instanceof String);
296         assertEquals("stringProperty value",
297                      "This is a string",
298                      (String) stringProperty);
299 
300 
301     }
302 
303 
304 }