(no commit message)
[utils] / support / test / org / wamblee / test / SpringTestCase.java
1 /*
2  * Copyright 2005 the original author or authors.
3  * 
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  * 
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  * 
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package org.wamblee.test;
18
19 import java.sql.Connection;
20 import java.sql.PreparedStatement;
21 import java.sql.ResultSet;
22 import java.sql.SQLException;
23 import java.util.ArrayList;
24 import java.util.Iterator;
25 import java.util.List;
26 import java.util.Map;
27 import java.util.TreeMap;
28
29 import javax.sql.DataSource;
30
31 import junit.framework.TestCase;
32
33 import org.apache.commons.logging.Log;
34 import org.apache.commons.logging.LogFactory;
35 import org.dbunit.DatabaseUnitException;
36 import org.dbunit.database.DatabaseConnection;
37 import org.dbunit.database.DatabaseSequenceFilter;
38 import org.dbunit.database.IDatabaseConnection;
39 import org.dbunit.dataset.FilteredDataSet;
40 import org.dbunit.dataset.IDataSet;
41 import org.dbunit.dataset.filter.ITableFilter;
42 import org.dbunit.operation.DatabaseOperation;
43 import org.hibernate.SessionFactory;
44 import org.jmock.cglib.MockObjectTestCase;
45 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
46 import org.springframework.beans.factory.config.BeanDefinition;
47 import org.springframework.beans.factory.support.RootBeanDefinition;
48 import org.springframework.context.ApplicationContext;
49 import org.springframework.context.support.ClassPathXmlApplicationContext;
50 import org.springframework.context.support.GenericApplicationContext;
51 import org.springframework.jdbc.core.JdbcTemplate;
52 import org.springframework.jdbc.datasource.DataSourceUtils;
53 import org.springframework.jdbc.datasource.DriverManagerDataSource;
54 import org.springframework.orm.hibernate3.HibernateTemplate;
55 import org.springframework.transaction.PlatformTransactionManager;
56 import org.springframework.transaction.TransactionDefinition;
57 import org.springframework.transaction.TransactionStatus;
58 import org.springframework.transaction.support.DefaultTransactionDefinition;
59 import org.springframework.transaction.support.TransactionCallback;
60 import org.springframework.transaction.support.TransactionCallbackWithoutResult;
61 import org.springframework.transaction.support.TransactionTemplate;
62 import org.wamblee.general.BeanKernel;
63 import org.wamblee.persistence.hibernate.HibernateMappingFiles;
64
65 /**
66  * Test case support class for spring tests.
67  */
68 public class SpringTestCase extends MockObjectTestCase {
69
70     private static final Log LOG = LogFactory.getLog(SpringTestCase.class);
71
72     /**
73      * Session factory bean name.
74      */
75     private static final String SESSION_FACTORY = "sessionFactory";
76
77     /**
78      * Data source bean name.
79      */
80     private static final String DATA_SOURCE = "dataSource";
81
82     /**
83      * Transaction manager bean name.
84      */
85     private static final String TRANSACTION_MANAGER = "transactionManager";
86
87     /**
88      * Name of the ConfigFileList bean that describes the Hibernate mapping
89      * files to use.
90      */
91     private static final String HIBERNATE_CONFIG_FILES = "hibernateMappingFiles";
92
93     /**
94      * Schema pattern.
95      */
96     private static final String SCHEMA_PATTERN = "%";
97
98     /**
99      * List of (String) configuration file locations for spring.
100      */
101     private String[] _configLocations;
102
103     /**
104      * Application context for storing bean definitions that vary on a test by
105      * test basis and cannot be hardcoded in the spring configuration files.
106      */
107     private GenericApplicationContext _parentContext;
108
109     /**
110      * Cached spring application context.
111      */
112     private ApplicationContext _context;
113
114     public SpringTestCase(Class<? extends SpringConfigFiles> aSpringFiles,
115             Class<? extends HibernateMappingFiles> aMappingFiles) {
116         try {
117             SpringConfigFiles springFiles = aSpringFiles.newInstance();
118             _configLocations = springFiles.toArray(new String[0]);
119         } catch (Exception e) {
120             fail("Could not construct spring config files class '"
121                     + aSpringFiles.getName() + "'");
122         }
123
124         // Register the Hibernate mapping files as a bean.
125         _parentContext = new GenericApplicationContext();
126         BeanDefinition lDefinition = new RootBeanDefinition(aMappingFiles);
127         _parentContext.registerBeanDefinition(HIBERNATE_CONFIG_FILES,
128                 lDefinition);
129         _parentContext.refresh();
130
131     }
132
133     /**
134      * Gets the spring context.
135      * 
136      * @return Spring context.
137      */
138     protected synchronized ApplicationContext getSpringContext() {
139         if (_context == null) {
140             _context = new ClassPathXmlApplicationContext(
141                     (String[]) _configLocations, _parentContext);
142             assertNotNull(_context);
143         }
144         return _context;
145     }
146
147     /**
148      * @return Hibernate session factory.
149      */
150     protected SessionFactory getSessionFactory() {
151         SessionFactory factory = (SessionFactory) getSpringContext().getBean(
152                 SESSION_FACTORY);
153         assertNotNull(factory);
154         return factory;
155     }
156
157     protected void setUp() throws Exception {
158         LOG.info("Performing setUp()");
159
160         super.setUp();
161
162         _context = null; // make sure we get a new application context for
163         // every
164         // new test.
165
166         BeanKernel.overrideBeanFactory(new TestSpringBeanFactory(
167                 getSpringContext()));
168
169         cleanDatabase();
170     }
171
172     /*
173      * (non-Javadoc)
174      * 
175      * @see junit.framework.TestCase#tearDown()
176      */
177     @Override
178     protected void tearDown() throws Exception {
179         try {
180             super.tearDown();
181         } finally {
182             LOG.info("tearDown() complete");
183         }
184     }
185
186     /**
187      * @return Transaction manager
188      */
189     protected PlatformTransactionManager getTransactionManager() {
190         PlatformTransactionManager manager = (PlatformTransactionManager) getSpringContext()
191                 .getBean(TRANSACTION_MANAGER);
192         assertNotNull(manager);
193         return manager;
194     }
195
196     /**
197      * @return Starts a new transaction.
198      */
199     protected TransactionStatus getTransaction() {
200         DefaultTransactionDefinition def = new DefaultTransactionDefinition();
201         def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
202
203         return getTransactionManager().getTransaction(def);
204     }
205
206     /**
207      * Returns the hibernate template for executing hibernate-specific
208      * functionality.
209      * 
210      * @return Hibernate template.
211      */
212     protected HibernateTemplate getTemplate() {
213         HibernateTemplate template = (HibernateTemplate) getSpringContext()
214                 .getBean(HibernateTemplate.class.getName());
215         assertNotNull(template);
216         return template;
217     }
218
219     /**
220      * Flushes the session. Should be called after some Hibernate work and
221      * before JDBC is used to check results.
222      * 
223      */
224     protected void flush() {
225         getTemplate().flush();
226     }
227
228     /**
229      * Flushes the session first and then removes all objects from the Session
230      * cache. Should be called after some Hibernate work and before JDBC is used
231      * to check results.
232      * 
233      */
234     protected void clear() {
235         flush();
236         getTemplate().clear();
237     }
238
239     /**
240      * Evicts the object from the session. This is essential for the
241      * implementation of unit tests where first an object is saved and is
242      * retrieved later. By removing the object from the session, Hibernate must
243      * retrieve the object again from the database.
244      * 
245      * @param aObject
246      */
247     protected void evict(Object aObject) {
248         getTemplate().evict(aObject);
249     }
250
251     /**
252      * Gets the connection.
253      * 
254      * @return Connection.
255      */
256     public Connection getConnection() {
257         return DataSourceUtils.getConnection(getDataSource());
258     }
259
260     public void cleanDatabase() throws SQLException {
261
262         if (!isDatabaseConfigured()) {
263             return;
264         }
265
266         String[] tables = getTableNames();
267
268         try {
269             IDatabaseConnection connection = new DatabaseConnection(
270                     getConnection());
271             ITableFilter filter = new DatabaseSequenceFilter(connection, tables);
272             IDataSet dataset = new FilteredDataSet(filter, connection
273                     .createDataSet(tables));
274
275             DatabaseOperation.DELETE_ALL.execute(connection, dataset);
276         } catch (DatabaseUnitException e) {
277             SQLException exc = new SQLException(e.getMessage());
278             exc.initCause(e);
279             throw exc;
280         }
281     }
282
283     /**
284      * @throws SQLException
285      */
286     public String[] getTableNames() throws SQLException {
287
288         List result = new ArrayList();
289         LOG.debug("Getting database table names to clean (schema: '"
290                 + SCHEMA_PATTERN + "'");
291
292         ResultSet tables = getConnection().getMetaData().getTables(null,
293                 SCHEMA_PATTERN, "%", new String[] { "TABLE" });
294         while (tables.next()) {
295             String table = tables.getString("TABLE_NAME");
296             // Make sure we do not touch hibernate's specific
297             // infrastructure tables.
298             if (!table.toLowerCase().startsWith("hibernate")) {
299                 result.add(table);
300                 LOG.debug("Adding " + table
301                         + " to list of tables to be cleaned.");
302             }
303         }
304         return (String[]) result.toArray(new String[0]);
305     }
306
307     /**
308      * @return
309      * @throws SQLException
310      */
311     public void emptyTables(List aTableList) throws SQLException {
312         Iterator liTable = aTableList.iterator();
313         while (liTable.hasNext()) {
314             emptyTable((String) liTable.next());
315         }
316     }
317
318     /**
319      * @return
320      * @throws SQLException
321      */
322     public void emptyTable(String aTable) throws SQLException {
323         executeSql("delete from " + aTable);
324     }
325
326     /**
327      * @return
328      * @throws SQLException
329      */
330     public void dropTable(String aTable) throws SQLException {
331         executeQuery("drop table " + aTable);
332     }
333
334     /**
335      * Executes an SQL statement within a transaction.
336      * 
337      * @param aSql
338      *            SQL statement.
339      * @return Return code of the corresponding JDBC call.
340      */
341     public int executeSql(final String aSql) {
342         return executeSql(aSql, new Object[0]);
343     }
344
345     /**
346      * Executes an SQL statement within a transaction. See
347      * {@link #setPreparedParam(int, PreparedStatement, Object)}for details on
348      * supported argument types.
349      * 
350      * @param aSql
351      *            SQL statement.
352      * @param aArg
353      *            Argument of the sql statement.
354      * @return Return code of the corresponding JDBC call.
355      */
356     public int executeSql(final String aSql, final Object aArg) {
357         return executeSql(aSql, new Object[] { aArg });
358     }
359
360     /**
361      * Executes an sql statement. See
362      * {@link #setPreparedParam(int, PreparedStatement, Object)}for details on
363      * supported argument types.
364      * 
365      * @param aSql
366      *            SQL query to execute.
367      * @param aArgs
368      *            Arguments.
369      * @return Number of rows updated.
370      */
371     public int executeSql(final String aSql, final Object[] aArgs) {
372         Map results = executeTransaction(new TestTransactionCallback() {
373             public Map execute() throws Exception {
374                 JdbcTemplate template = new JdbcTemplate(getDataSource());
375                 int result = template.update(aSql, aArgs);
376
377                 Map<String, Integer> map = new TreeMap<String, Integer>();
378                 map.put("result", new Integer(result));
379
380                 return map;
381             }
382         });
383
384         return ((Integer) results.get("result")).intValue();
385     }
386
387     /**
388      * Executes a transaction with a result.
389      * 
390      * @param aCallback
391      *            Callback to do your transactional work.
392      * @return Result.
393      */
394     public Object executeTransaction(TransactionCallback aCallback) {
395         TransactionTemplate lTemplate = new TransactionTemplate(
396                 getTransactionManager());
397         return lTemplate.execute(aCallback);
398     }
399
400     /**
401      * Executes a transaction without a result.
402      * 
403      * @param aCallback
404      *            Callback to do your transactional work. .
405      */
406     protected void executeTransaction(TransactionCallbackWithoutResult aCallback) {
407         TransactionTemplate template = new TransactionTemplate(
408                 getTransactionManager());
409         template.execute(aCallback);
410     }
411
412     /**
413      * Executes a transaction with a result, causing the testcase to fail if any
414      * type of exception is thrown.
415      * 
416      * @param aCallback
417      *            Code to be executed within the transaction.
418      * @return Result.
419      */
420     public Map executeTransaction(final TestTransactionCallback aCallback) {
421         return (Map) executeTransaction(new TransactionCallback() {
422             public Object doInTransaction(TransactionStatus aArg) {
423                 try {
424                     return aCallback.execute();
425                 } catch (Exception e) {
426                     // test case must fail.
427                     e.printStackTrace();
428                     throw new RuntimeException(e);
429                 }
430             }
431         });
432     }
433
434     /**
435      * Executes a transaction with a result, causing the testcase to fail if any
436      * type of exception is thrown.
437      * 
438      * @param aCallback
439      *            Code to be executed within the transaction.
440      */
441     public void executeTransaction(
442             final TestTransactionCallbackWithoutResult aCallback) {
443         executeTransaction(new TransactionCallbackWithoutResult() {
444             public void doInTransactionWithoutResult(TransactionStatus aArg) {
445                 try {
446                     aCallback.execute();
447                 } catch (Exception e) {
448                     // test case must fail.
449                     throw new RuntimeException(e.getMessage(), e);
450                 }
451             }
452         });
453     }
454
455     /**
456      * Executes an SQL query within a transaction.
457      * 
458      * @param aSql
459      *            Query to execute.
460      * @return Result set.
461      */
462     public ResultSet executeQuery(String aSql) {
463         return executeQuery(aSql, new Object[0]);
464     }
465
466     /**
467      * Executes a query with a single argument. See
468      * {@link #setPreparedParam(int, PreparedStatement, Object)}for details on
469      * supported argument types.
470      * 
471      * @param aSql
472      *            Query.
473      * @param aArg
474      *            Argument.
475      * @return Result set.
476      */
477     public ResultSet executeQuery(String aSql, Object aArg) {
478         return executeQuery(aSql, new Object[] { aArg });
479     }
480
481     /**
482      * Executes a query within a transaction. See
483      * {@link #setPreparedParam(int, PreparedStatement, Object)}for details on
484      * supported argument types.
485      * 
486      * @param aSql
487      *            Sql query.
488      * @param aArgs
489      *            Arguments to the query.
490      * @return Result set.
491      */
492     public ResultSet executeQuery(final String aSql, final Object[] aArgs) {
493         Map results = executeTransaction(new TestTransactionCallback() {
494             public Map execute() throws Exception {
495                 Connection connection = getConnection();
496
497                 PreparedStatement statement = connection.prepareStatement(aSql);
498                 setPreparedParams(aArgs, statement);
499
500                 ResultSet resultSet = statement.executeQuery();
501                 TreeMap results = new TreeMap();
502                 results.put("resultSet", resultSet);
503
504                 return results;
505             }
506         });
507
508         return (ResultSet) results.get("resultSet");
509     }
510
511     /**
512      * Sets the values of a prepared statement. See
513      * {@link #setPreparedParam(int, PreparedStatement, Object)}for details on
514      * supported argument types.
515      * 
516      * @param aArgs
517      *            Arguments to the prepared statement.
518      * @param aStatement
519      *            Prepared statement
520      * @throws SQLException
521      */
522     private void setPreparedParams(final Object[] aArgs,
523             PreparedStatement aStatement) throws SQLException {
524         for (int i = 1; i <= aArgs.length; i++) {
525             setPreparedParam(i, aStatement, aArgs[i - 1]);
526         }
527     }
528
529     /**
530      * Sets a prepared statement parameter.
531      * 
532      * @param aIndex
533      *            Index of the parameter.
534      * @param aStatement
535      *            Prepared statement.
536      * @param aObject
537      *            Value Must be of type Integer, Long, or String. TODO extend
538      *            with more types of values.
539      * @throws SQLException
540      */
541     private void setPreparedParam(int aIndex, PreparedStatement aStatement,
542             Object aObject) throws SQLException {
543         if (aObject instanceof Integer) {
544             aStatement.setInt(aIndex, ((Integer) aObject).intValue());
545         } else if (aObject instanceof Long) {
546             aStatement.setLong(aIndex, ((Integer) aObject).longValue());
547         } else if (aObject instanceof String) {
548             aStatement.setString(aIndex, (String) aObject);
549         } else {
550             TestCase.fail("Unsupported object type for prepared statement: "
551                     + aObject.getClass() + " value: " + aObject
552                     + " statement: " + aStatement);
553         }
554     }
555
556     private boolean isDatabaseConfigured() {
557         try {
558             getDataSource();
559         } catch (NoSuchBeanDefinitionException e) {
560             return false;
561         }
562         return true;
563     }
564
565     /**
566      * @return Returns the dataSource.
567      */
568     public DataSource getDataSource() {
569         DataSource ds = (DriverManagerDataSource) getSpringContext().getBean(
570                 DATA_SOURCE);
571         assertNotNull(ds);
572         return ds;
573     }
574
575     /**
576      * @return
577      * @throws SQLException
578      */
579     protected int getTableSize(String aTable) throws SQLException {
580         ResultSet resultSet = executeQuery("select * from " + aTable);
581         int count = 0;
582
583         while (resultSet.next()) {
584             count++;
585         }
586
587         return count;
588     }
589
590     protected int countResultSet(ResultSet aResultSet) throws SQLException {
591         int count = 0;
592
593         while (aResultSet.next()) {
594             count++;
595         }
596
597         return count;
598     }
599
600 }