import javax.sql.DataSource;
-
/**
- * Test support class for database testing. Currently, this still requires
- * the spring platform transaction manager and hibernate template.
+ * Test support class for database testing. Currently, this still requires the
+ * spring platform transaction manager and hibernate template.
*/
public class DatabaseTesterComponent {
- /**
- * DOCUMENT ME!
- */
- private static final Log LOG = LogFactory.getLog(DatabaseTesterComponent.class);
+ private static final Log LOG = LogFactory
+ .getLog(DatabaseTesterComponent.class);
/**
* Schema pattern.
*/
private ApplicationContext context;
- /**
- * DOCUMENT ME!
- */
private HibernateTemplate hibernateTemplate;
- /**
- * DOCUMENT ME!
- */
private PlatformTransactionManager transactionManager;
- /**
- * DOCUMENT ME!
- */
private DataSource dataSource;
-/**
+ /**
* Creates a new DatabaseTesterComponent object.
- *
- * @param aHibernateTemplate DOCUMENT ME!
- * @param aTransactionManager DOCUMENT ME!
- * @param aDataSource DOCUMENT ME!
+ *
*/
public DatabaseTesterComponent(HibernateTemplate aHibernateTemplate,
PlatformTransactionManager aTransactionManager, DataSource aDataSource) {
- hibernateTemplate = aHibernateTemplate;
- transactionManager = aTransactionManager;
- dataSource = aDataSource;
+ hibernateTemplate = aHibernateTemplate;
+ transactionManager = aTransactionManager;
+ dataSource = aDataSource;
}
/**
- * DOCUMENT ME!
- *
+ *
* @return Hibernate session factory.
*/
protected SessionFactory getSessionFactory() {
/**
* Performs common initialization for test cases:
- * <li>Cleaning the database.</li>
- * </ul>
- *
+ * <ul>
+ * <li>Cleaning the database.</li>
+ * </ul>
+ *
* @throws Exception
*/
public void setUp() throws Exception {
}
/**
- * Performs common tear down after execution of a test case.
- * Currenlty this method does nothing.
- *
+ * Performs common tear down after execution of a test case. Currenlty this
+ * method does nothing.
+ *
* @throws Exception
*/
protected void tearDown() throws Exception {
}
/**
- * DOCUMENT ME!
- *
+ *
* @return Transaction manager
*/
protected PlatformTransactionManager getTransactionManager() {
}
/**
- * DOCUMENT ME!
- *
+ *
* @return Starts a new transaction.
*/
protected TransactionStatus getTransaction() {
/**
* Returns the hibernate template for executing hibernate-specific
* functionality.
- *
+ *
* @return Hibernate template.
*/
public HibernateTemplate getTemplate() {
}
/**
- * Flushes the session. Should be called after some Hibernate work
- * and before JDBC is used to check results.
+ * 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.
+ * 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();
/**
* Evicts the object from the session. This is essential for the
* implementation of unit tests where first an object is saved and is
- * retrieved later. By removing the object from the session, Hibernate
- * must retrieve the object again from the database.
- *
+ * retrieved later. By removing the object from the session, Hibernate must
+ * retrieve the object again from the database.
+ *
* @param aObject
*/
protected void evict(Object aObject) {
/**
* Gets the connection.
- *
+ *
* @return Connection.
*/
public Connection getConnection() {
return DataSourceUtils.getConnection(getDataSource());
}
- /**
- * DOCUMENT ME!
- *
- * @throws SQLException DOCUMENT ME!
- */
public void cleanDatabase() throws SQLException {
if (!isDatabaseConfigured()) {
return;
String[] tables = getTableNames();
try {
- IDatabaseConnection connection = new DatabaseConnection(getConnection());
- ITableFilter filter = new DatabaseSequenceFilter(connection,
- tables);
- IDataSet dataset = new FilteredDataSet(filter,
- connection.createDataSet(tables));
+ IDatabaseConnection connection = new DatabaseConnection(
+ getConnection());
+ ITableFilter filter = new DatabaseSequenceFilter(connection, tables);
+ IDataSet dataset = new FilteredDataSet(filter, connection
+ .createDataSet(tables));
DatabaseOperation.DELETE_ALL.execute(connection, dataset);
} catch (DatabaseUnitException e) {
}
/**
- * DOCUMENT ME!
- *
- * @return DOCUMENT ME!
- *
+ *
+ *
* @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" });
+ ResultSet tables = getConnection().getMetaData().getTables(null,
+ SCHEMA_PATTERN, "%", new String[] { "TABLE" });
while (tables.next()) {
String table = tables.getString("TABLE_NAME");
// 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.");
}
}
}
/**
- * DOCUMENT ME!
- *
- * @param aTableList DOCUMENT ME!
- *
+ *
+ *
* @throws SQLException
*/
public void emptyTables(List aTableList) throws SQLException {
}
/**
- * DOCUMENT ME!
- *
- * @param aTable DOCUMENT ME!
- *
+ *
+ *
* @throws SQLException
*/
public void emptyTable(String aTable) throws SQLException {
}
/**
- * DOCUMENT ME!
- *
- * @param aTable DOCUMENT ME!
- *
+ *
+ *
* @throws SQLException
*/
public void dropTable(String aTable) throws SQLException {
/**
* Executes an SQL statement within a transaction.
- *
- * @param aSql SQL statement.
- *
+ *
+ * @param aSql
+ * SQL statement.
+ *
* @return Return code of the corresponding JDBC call.
*/
public int executeSql(final String aSql) {
}
/**
- * Executes an SQL statement within a transaction. See {@link
- * #setPreparedParam(int, PreparedStatement, Object)}for details on
+ * Executes an SQL statement within a transaction. See
+ * {@link #setPreparedParam(int, PreparedStatement, Object)}for details on
* supported argument types.
- *
- * @param aSql SQL statement.
- * @param aArg Argument of the sql statement.
- *
+ *
+ * @param 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) {
}
/**
- * Executes an sql statement. See {@link #setPreparedParam(int,
- * PreparedStatement, Object)}for details on supported argument types.
- *
- * @param aSql SQL query to execute.
- * @param aArgs Arguments.
- *
+ * Executes an sql statement. See
+ * {@link #setPreparedParam(int, PreparedStatement, Object)}for details on
+ * supported argument types.
+ *
+ * @param aSql
+ * SQL query to execute.
+ * @param aArgs
+ * Arguments.
+ *
* @return Number of rows updated.
*/
public int executeSql(final String aSql, final Object[] aArgs) {
Map results = executeTransaction(new TestTransactionCallback() {
- public Map execute() throws Exception {
- JdbcTemplate template = new JdbcTemplate(getDataSource());
- int result = template.update(aSql,
- aArgs);
+ public Map execute() throws Exception {
+ JdbcTemplate template = new JdbcTemplate(getDataSource());
+ int result = template.update(aSql, aArgs);
- Map<String, Integer> map = new TreeMap<String, Integer>();
- map.put("result", new Integer(result));
+ Map<String, Integer> map = new TreeMap<String, Integer>();
+ map.put("result", new Integer(result));
- return map;
- }
- });
+ return map;
+ }
+ });
return ((Integer) results.get("result")).intValue();
}
/**
* Executes a transaction with a result.
- *
- * @param aCallback Callback to do your transactional work.
- *
+ *
+ * @param aCallback
+ * Callback to do your transactional work.
+ *
* @return Result.
*/
public Object executeTransaction(TransactionCallback aCallback) {
- TransactionTemplate lTemplate = new TransactionTemplate(getTransactionManager());
+ TransactionTemplate lTemplate = new TransactionTemplate(
+ getTransactionManager());
return lTemplate.execute(aCallback);
}
/**
* Executes a transaction without a result.
- *
- * @param aCallback Callback to do your transactional work. .
+ *
+ * @param aCallback
+ * Callback to do your transactional work. .
*/
public void executeTransaction(TransactionCallbackWithoutResult aCallback) {
- TransactionTemplate template = new TransactionTemplate(getTransactionManager());
+ TransactionTemplate template = new TransactionTemplate(
+ getTransactionManager());
template.execute(aCallback);
}
/**
- * Executes a transaction with a result, causing the testcase to
- * fail if any type of exception is thrown.
- *
- * @param aCallback Code to be executed within the transaction.
- *
+ * Executes a transaction with a result, causing the testcase to fail if any
+ * type of exception is thrown.
+ *
+ * @param aCallback
+ * Code to be executed within the transaction.
+ *
* @return Result.
- *
- * @throws RuntimeException DOCUMENT ME!
+ *
*/
public Map executeTransaction(final TestTransactionCallback aCallback) {
return (Map) executeTransaction(new TransactionCallback() {
- public Object doInTransaction(TransactionStatus aArg) {
- try {
- return aCallback.execute();
- } catch (Exception e) {
- // test case must fail.
- e.printStackTrace();
- throw new RuntimeException(e);
- }
+ public Object doInTransaction(TransactionStatus aArg) {
+ try {
+ return aCallback.execute();
+ } catch (Exception e) {
+ // test case must fail.
+ e.printStackTrace();
+ throw new RuntimeException(e);
}
- });
+ }
+ });
}
/**
- * Executes a transaction with a result, causing the testcase to
- * fail if any type of exception is thrown.
- *
- * @param aCallback Code to be executed within the transaction.
- *
- * @throws RuntimeException DOCUMENT ME!
+ * Executes a transaction with a result, causing the testcase to fail if any
+ * type of exception is thrown.
+ *
+ * @param aCallback
+ * Code to be executed within the transaction.
+ *
*/
public void executeTransaction(
final TestTransactionCallbackWithoutResult aCallback) {
executeTransaction(new TransactionCallbackWithoutResult() {
- public void doInTransactionWithoutResult(TransactionStatus aArg) {
- try {
- aCallback.execute();
- } catch (Exception e) {
- // test case must fail.
- throw new RuntimeException(e.getMessage(), e);
- }
+ public void doInTransactionWithoutResult(TransactionStatus aArg) {
+ try {
+ aCallback.execute();
+ } catch (Exception e) {
+ // test case must fail.
+ throw new RuntimeException(e.getMessage(), e);
}
- });
+ }
+ });
}
/**
* Executes an SQL query.
- *
- * @param aSql Query to execute.
- *
+ *
+ * @param aSql
+ * Query to execute.
+ *
* @return Result set.
*/
public ResultSet executeQuery(String aSql) {
}
/**
- * Executes a query with a single argument. See {@link
- * #setPreparedParam(int, PreparedStatement, Object)}for details on
+ * Executes a query with a single argument. See
+ * {@link #setPreparedParam(int, PreparedStatement, Object)}for details on
* supported argument types.
- *
- * @param aSql Query.
- * @param aArg Argument.
- *
+ *
+ * @param aSql
+ * Query.
+ * @param aArg
+ * Argument.
+ *
* @return Result set.
*/
public ResultSet executeQuery(String aSql, Object aArg) {
}
/**
- * Executes a query. See {@link #setPreparedParam(int,
- * PreparedStatement, Object)}for details on supported argument types.
- *
- * @param aSql Sql query.
- * @param aArgs Arguments to the query.
- *
+ * Executes a query. See
+ * {@link #setPreparedParam(int, PreparedStatement, Object)}for details on
+ * supported argument types.
+ *
+ * @param aSql
+ * Sql query.
+ * @param aArgs
+ * Arguments to the query.
+ *
* @return Result set.
- *
- * @throws RuntimeException DOCUMENT ME!
+ *
*/
public ResultSet executeQuery(final String aSql, final Object[] aArgs) {
try {
- Connection connection = getConnection();
+ Connection connection = getConnection();
- PreparedStatement statement = connection.prepareStatement(aSql);
+ PreparedStatement statement = connection.prepareStatement(aSql);
setPreparedParams(aArgs, statement);
return statement.executeQuery();
}
/**
- * Sets the values of a prepared statement. See {@link
- * #setPreparedParam(int, PreparedStatement, Object)}for details on
+ * Sets the values of a prepared statement. See
+ * {@link #setPreparedParam(int, PreparedStatement, Object)}for details on
* supported argument types.
- *
- * @param aArgs Arguments to the prepared statement.
- * @param aStatement Prepared statement
- *
+ *
+ * @param aArgs
+ * Arguments to the prepared statement.
+ * @param aStatement
+ * Prepared statement
+ *
* @throws SQLException
*/
private void setPreparedParams(final Object[] aArgs,
/**
* Sets a prepared statement parameter.
- *
- * @param aIndex Index of the parameter.
- * @param aStatement Prepared statement.
- * @param aObject Value Must be of type Integer, Long, or String.
- *
+ *
+ * @param aIndex
+ * Index of the parameter.
+ * @param aStatement
+ * Prepared statement.
+ * @param aObject
+ * Value Must be of type Integer, Long, or String.
+ *
* @throws SQLException
*/
private void setPreparedParam(int aIndex, PreparedStatement aStatement,
} 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);
}
}
- /**
- * DOCUMENT ME!
- *
- * @return DOCUMENT ME!
- */
private boolean isDatabaseConfigured() {
try {
getDataSource();
}
/**
- * DOCUMENT ME!
- *
+ *
* @return Returns the dataSource.
*/
public DataSource getDataSource() {
}
/**
- * DOCUMENT ME!
- *
- * @param aTable DOCUMENT ME!
- *
+ *
+ *
* @return
- *
+ *
* @throws SQLException
*/
public int getTableSize(final String aTable) throws SQLException {
ResultSet resultSet = executeQuery("select * from " + aTable);
- int count = 0;
+ int count = 0;
while (resultSet.next()) {
count++;
return count;
}
- /**
- * DOCUMENT ME!
- *
- * @param aResultSet DOCUMENT ME!
- *
- * @return DOCUMENT ME!
- *
- * @throws SQLException DOCUMENT ME!
- */
public int countResultSet(ResultSet aResultSet) throws SQLException {
int count = 0;
git://wamblee.org / utils / blobdiff