/*
* Copyright 2005 the original author or authors.
- *
+ *
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
package org.wamblee.system.spring.component;
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.TreeMap;
-
-import javax.sql.DataSource;
-
import junit.framework.TestCase;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
+
import org.dbunit.DatabaseUnitException;
+
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.DatabaseSequenceFilter;
import org.dbunit.database.IDatabaseConnection;
+
import org.dbunit.dataset.FilteredDataSet;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.filter.ITableFilter;
+
import org.dbunit.operation.DatabaseOperation;
+
import org.hibernate.SessionFactory;
+
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+
import org.springframework.context.ApplicationContext;
+
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceUtils;
+
import org.springframework.orm.hibernate3.HibernateTemplate;
+
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;
+
import org.wamblee.test.spring.TestTransactionCallback;
import org.wamblee.test.spring.TestTransactionCallbackWithoutResult;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import javax.sql.DataSource;
+
/**
* Test support class for database testing. Currently, this still requires the
* spring platform transaction manager and hibernate template.
*/
public class DatabaseTesterComponent {
-
private static final Log LOG = LogFactory
- .getLog(DatabaseTesterComponent.class);
+ .getLog(DatabaseTesterComponent.class);
/**
* Schema pattern.
private DataSource dataSource;
+ /**
+ * Creates a new DatabaseTesterComponent object.
+ *
+ */
public DatabaseTesterComponent(HibernateTemplate aHibernateTemplate,
- PlatformTransactionManager aTransactionManager,
- DataSource aDataSource) {
+ PlatformTransactionManager aTransactionManager, DataSource aDataSource) {
hibernateTemplate = aHibernateTemplate;
transactionManager = aTransactionManager;
dataSource = aDataSource;
}
/**
+ *
* @return Hibernate session factory.
*/
protected SessionFactory getSessionFactory() {
/**
* Performs common initialization for test cases:
* <ul>
- * <li>Cleaning the database. </li>
+ * <li>Cleaning the database.</li>
* </ul>
*
* @throws Exception
}
/**
+ *
* @return Transaction manager
*/
protected PlatformTransactionManager getTransactionManager() {
}
/**
+ *
* @return Starts a new transaction.
*/
protected TransactionStatus getTransaction() {
/**
* Flushes the session. Should be called after some Hibernate work and
* before JDBC is used to check results.
- *
*/
public void flush() {
getTemplate().flush();
* Flushes the session first and then removes all objects from the Session
* cache. Should be called after some Hibernate work and before JDBC is used
* to check results.
- *
*/
public void clear() {
flush();
}
public void cleanDatabase() throws SQLException {
-
if (!isDatabaseConfigured()) {
return;
}
try {
IDatabaseConnection connection = new DatabaseConnection(
- getConnection());
+ getConnection());
ITableFilter filter = new DatabaseSequenceFilter(connection, tables);
IDataSet dataset = new FilteredDataSet(filter, connection
- .createDataSet(tables));
+ .createDataSet(tables));
DatabaseOperation.DELETE_ALL.execute(connection, dataset);
} catch (DatabaseUnitException e) {
}
/**
+ *
+ *
* @throws SQLException
*/
public String[] getTableNames() throws SQLException {
-
List<String> result = new ArrayList<String>();
- LOG.debug("Getting database table names to clean (schema: '"
- + SCHEMA_PATTERN + "'");
+ LOG.debug("Getting database table names to clean (schema: '" +
+ SCHEMA_PATTERN + "'");
ResultSet tables = getConnection().getMetaData().getTables(null,
- SCHEMA_PATTERN, "%", new String[] { "TABLE" });
+ SCHEMA_PATTERN, "%", new String[] { "TABLE" });
+
while (tables.next()) {
String table = tables.getString("TABLE_NAME");
+
// Make sure we do not touch hibernate's specific
// infrastructure tables.
if (!table.toLowerCase().startsWith("hibernate")) {
result.add(table);
- LOG.debug("Adding " + table
- + " to list of tables to be cleaned.");
+ LOG.debug("Adding " + table +
+ " to list of tables to be cleaned.");
}
}
+
return (String[]) result.toArray(new String[0]);
}
/**
- * @return
+ *
+ *
* @throws SQLException
*/
public void emptyTables(List aTableList) throws SQLException {
Iterator liTable = aTableList.iterator();
+
while (liTable.hasNext()) {
emptyTable((String) liTable.next());
}
}
/**
- * @return
+ *
+ *
* @throws SQLException
*/
public void emptyTable(String aTable) throws SQLException {
}
/**
- * @return
+ *
+ *
* @throws SQLException
*/
public void dropTable(String aTable) throws SQLException {
*
* @param aSql
* SQL statement.
+ *
* @return Return code of the corresponding JDBC call.
*/
public int executeSql(final String aSql) {
* SQL statement.
* @param aArg
* Argument of the sql statement.
+ *
* @return Return code of the corresponding JDBC call.
*/
public int executeSql(final String aSql, final Object aArg) {
* SQL query to execute.
* @param aArgs
* Arguments.
+ *
* @return Number of rows updated.
*/
public int executeSql(final String aSql, final Object[] aArgs) {
*
* @param aCallback
* Callback to do your transactional work.
+ *
* @return Result.
*/
public Object executeTransaction(TransactionCallback aCallback) {
TransactionTemplate lTemplate = new TransactionTemplate(
- getTransactionManager());
+ getTransactionManager());
+
return lTemplate.execute(aCallback);
}
*/
public void executeTransaction(TransactionCallbackWithoutResult aCallback) {
TransactionTemplate template = new TransactionTemplate(
- getTransactionManager());
+ getTransactionManager());
template.execute(aCallback);
}
*
* @param aCallback
* Code to be executed within the transaction.
+ *
* @return Result.
+ *
*/
public Map executeTransaction(final TestTransactionCallback aCallback) {
return (Map) executeTransaction(new TransactionCallback() {
*
* @param aCallback
* Code to be executed within the transaction.
+ *
*/
public void executeTransaction(
- final TestTransactionCallbackWithoutResult aCallback) {
+ final TestTransactionCallbackWithoutResult aCallback) {
executeTransaction(new TransactionCallbackWithoutResult() {
public void doInTransactionWithoutResult(TransactionStatus aArg) {
try {
*
* @param aSql
* Query to execute.
+ *
* @return Result set.
*/
public ResultSet executeQuery(String aSql) {
* Query.
* @param aArg
* Argument.
+ *
* @return Result set.
*/
public ResultSet executeQuery(String aSql, Object aArg) {
* Sql query.
* @param aArgs
* Arguments to the query.
+ *
* @return Result set.
+ *
*/
public ResultSet executeQuery(final String aSql, final Object[] aArgs) {
try {
* Arguments to the prepared statement.
* @param aStatement
* Prepared statement
+ *
* @throws SQLException
*/
private void setPreparedParams(final Object[] aArgs,
- PreparedStatement aStatement) throws SQLException {
+ PreparedStatement aStatement) throws SQLException {
for (int i = 1; i <= aArgs.length; i++) {
setPreparedParam(i, aStatement, aArgs[i - 1]);
}
* @param aStatement
* Prepared statement.
* @param aObject
- * Value Must be of type Integer, Long, or String.
+ * Value Must be of type Integer, Long, or String.
+ *
* @throws SQLException
*/
private void setPreparedParam(int aIndex, PreparedStatement aStatement,
- Object aObject) throws SQLException {
+ Object aObject) throws SQLException {
if (aObject instanceof Integer) {
aStatement.setInt(aIndex, ((Integer) aObject).intValue());
} else if (aObject instanceof Long) {
} else if (aObject instanceof String) {
aStatement.setString(aIndex, (String) aObject);
} else {
- TestCase.fail("Unsupported object type for prepared statement: "
- + aObject.getClass() + " value: " + aObject
- + " statement: " + aStatement);
+ TestCase.fail("Unsupported object type for prepared statement: " +
+ aObject.getClass() + " value: " + aObject + " statement: " +
+ aStatement);
}
}
} catch (NoSuchBeanDefinitionException e) {
return false;
}
+
return true;
}
/**
+ *
* @return Returns the dataSource.
*/
public DataSource getDataSource() {
}
/**
+ *
+ *
* @return
+ *
* @throws SQLException
*/
public int getTableSize(final String aTable) throws SQLException {
-
ResultSet resultSet = executeQuery("select * from " + aTable);
int count = 0;
while (resultSet.next()) {
count++;
}
+
return count;
}
return count;
}
-
}
git://wamblee.org / utils / blobdiff