Spring out-of-box provide the following functionality:

• Transaction management though spring container.
• Dependency Injection feature.
• Spring Ioc Container caching between execution.

On Surface, Spring Test cases can be classified into

• JUnit with Dependency Injection.
• Junit with Dependency Injection and Transactional Control.

Spring based JUnit with Dependency Injection

For JUnit Classes which need to use Dependency injection feature of spring will be required to inherit the class ‘AbstractDependencyInjectionSpringContextTests‘ and the subclass need to implement the superclass’s abstract method ‘protected abstract String[] getConfigLocations();’ the implementation of this method need to return the spring configuration XML files which are required to participate in the execution of the test case.
E.g,
public final class ExampleDaoTests extends AbstractDependencyInjectionSpringContextTests {

// this reference will be automatically injected through spring
private ExampleDao exampleDao;

// a setter method to enable DI for the Dao instance variable
public void setExampleDao(ExampleDao exampleDao) {
this.exampleDao = exampleDao;
}

public void testExample() throws Exception {
BusinessObject bo = this.exampleDao.loadBo(new Long(10));
assertNotNull(title);
}

// specifies the Spring configuration to load for this test.
protected String[] getConfigLocations() {
return new String[] { “classpath:com/foo/daos.xml” };
}
}

<< Spring Configuration file >>

<?xml version=”1.0? encoding=”UTF-8??>
<!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN 2.0//EN”
“http://www.springframework.org/dtd/http://www.springframework.org/dtd/spring-beans-2.0.dtd”>
<beans>

<!– this bean will be injected into the ExampleDaoTests class –>
<bean id=”exampleDao” class=”com.foo.dao.hibernate.ExampleDao”>
<property name=”sessionFactory” ref=”sessionFactory”/>
</bean>

<bean id=”sessionFactory” class=”org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
<!– dependencies elided for clarity –>
</bean>
</beans>

Spring based JUnit with Transaction Control/ Integration Test

One common problem in integration test is to access a database and still maintain the state of the persistence store. When using a database, changes to the database state may effect the future tests and CURD operations can’t be verified outside a transaction.

The org.springframework.test.AbstractTransactionalSpringContextTests superclass (and subclasses) exist to meet this requirement. By default, this class create and rollback a transaction for each test. From a developer/ development point of view, You simply write code that assumes the existence of a transaction.

It has to be noted that, this class extends AbstractDependencyInjectionSpringContextTests so spring dependency injection is made available for all the subclasses extending AbstractTransactionalSpringContextTests

Spring based JUnit also provides an option to commit a transaction (unusual, but occasionally useful when you want a particular test to populate the database) - you can invoke the setComplete() method inherited from AbstractTransactionalSpringContextTests. This will force the transaction to commit instead of roll back.

There is also convenient ability to end a transaction before the test case ends, through calling the endTransaction() method. This will roll back the transaction by default, and commit it only if setComplete() had previously been called. This functionality is useful if you want to test the behavior of ‘disconnected’ data objects, such as Hibernate-mapped objects that will be used in a web or remoting tier outside a transaction. Often, lazy loading errors are discovered only through UI testing; if you call endTransaction() you can ensure correct operation of the UI through your JUnit test suite.
E.g,

//as this test class extends ‘AbstractTransactionalSpringContextTests’ so all the
//test methods will be bound with a transaction.
public final class ExampleDaoTests extends AbstractTransactionalSpringContextTests {

// this reference will be automatically injected through spring
private ExampleDao exampleDao;

// a setter method to enable DI for the Dao instance variable
public void setExampleDao(ExampleDao exampleDao) {
this.exampleDao = exampleDao;
}

public void testExample() throws Exception {
BusinessObject bo = createBo(); // create the Business Objects
exampleDao.create(bo); // Business Object will be created

//now retrieve the object which was created in the database.
BusinessObject returnedObject = exampleDao.findById(bo.getId());
assertEquals(bo.getId(), returnedObject.getId());
//after the execution of the test method, data which was inse
}

// specifies the Spring configuration to load for this test.
protected String[] getConfigLocations() {
return new String[] { “classpath:com/foo/daos.xml” };
}
}

<< Spring Configuration file >>

<?xml version=”1.0? encoding=”UTF-8??>
<!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN 2.0//EN”
“http://www.springframework.org/dtd/http://www.springframework.org/dtd/spring-beans-2.0.dtd”>
<beans>

<!– this bean will be injected into the ExampleDaoTests class –>
<bean id=”exampleDao” class=”com.foo.dao.hibernate.ExampleDao”>
<property name=”sessionFactory” ref=”sessionFactory”/>
</bean>

<bean id=”sessionFactory” class=”org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
<!– dependencies elided for clarity –>
</bean>

</beans>

<tx:annotation-driven transaction-manager=”txManager”/> where txManager points the underlying transaction manager and the tx namespace refers to http://www.springframework.org/schema/tx

• Transaction rollback can be controlled though Transactional annotation for the property ‘rollbackFor’ and ‘rollbackForClassName’.
• Timeout for the transaction can be controlled through the Transactional annotation for the property ‘timeout’.
• Example usage for Declarative transaction with Annotations

(more…)

This is different from Bean utils, which copies the data recursively for the object which has the same property names. Bean-Utils has a restriction for working with complex data types.

Dozer tool can be found here

here’s some of the key advantages found on Dozer

• Can define the mapping / exlude mapping in a configuration mapping file.
• Support for Spring (tested Dozer 3.0/ 3.1 with Spring 2.0).

Recommanded Usage Scenario:

• Highly recommanded for the scenarios, where the usage of design patterns for Data Transfer Object (Dto) and Business Objects (Bo).
• For scenario of Data transfer from UI form elements to Data transfer objects (Dto).

Disadvantages for Dozer

• I used this tool under Java 5/ Spring 2.0. Dozer was instantiated using Spring. our architecture was like, all the business Objects (Bo) were placed in one project. Had a facade (facade has Dto) for a set of functionalitie. Now the problem was the definition of spring configuration for the dozer, as Dto and Bo were present in various projects, so this created a need for the definition spring configuration definition on a top level project than at leaf level.