Traditional examples provide a List mocking example or foo/bar example which I find it mostly annoying since it doesn’t teach you how to solve real problems. And the documentation is verbose and crams with unnecessary features confusing us further. In this tutorial, I’ll dive straight into a relevant example of mock testing Daos in Service layer. I’m not a big fan of Daos anymore (after the advent of JPA), however for the purposes of this tutorial, it’ll be easier to explain.

Consider a Profile entity (like facebook user profile) with daos/services: ProfileDao/JPAProfileDao, ProfileService/ProfileServiceImpl. To complicate things further, say you are using DTOs since it’s a client server app with a GWT front end. You might need a simple mapper class. Let’s call it ProfileMapper/ProfileMapperImpl.

@Service("profileService")
public class ProfileServiceImpl implements ProfileService {
	private final ProfileDao profileDao;
	private final ProfileMapper profileMapper;

	@Inject
	public ProfileServiceImpl(final ProfileDao profileDao, final ProfileMapper profileMapper) {
		this.profileDao = profileDao;
		this.profileMapper = profileMapper;
	}

	@Transactional
	public void create(ProfileDto profile) throws DuplicateProfileException {
		if (profile == null) {
			throw new IllegalArgumentException("profile cannot be null.");
		}

		Profile profile = profileMapper.toEntity(profile);
		// set default state as active
		profile .setIsActive(true);

		try {
			profileDao.save(profile);
		}
		catch (DuplicateKeyException e) {
			logger.warn("Unable to save profile with userId: " + profile.getUserId() + " already exists.");
			throw new DuplicateProfileException();
		}
		logger.debug("Profile saved successfully.");
	}

	@Transactional(readOnly = true)
	public ProfileDto read(String userId) throws InvalidProfileException {
		validateProfileInfo(userId);

		ProfileDto profileDto = null;
		Profile profile = profileDao.read(userId);
		if (profile != null) {
			profileDto = profileMapper.fromEntity(profile);
			logger.debug("Profile retrieved successfully.");
		}
		else {
			logger.debug("...");
		}
		return profileDto;
	}

	...
}

Now, in order to test ProfileService, you need to mock out ProfileMapper and ProfileDao, right? Let’s see how we do this in a simple JUnit 4.4+ test.

import static org.mockito.Mockito.*;

@RunWith(MockitoJUnitRunner.class)
public class ProfileServiceTest {

	@Mock
	ProfileDao profileDao;

	@Mock
	ProfileMapper profileMapper;

	// Can't use @InjectMocks because Mockito doesn't support constructor injection
	// As a workaround use @Before below to initialize service with stubs
	ProfileService profileService;

	@Before
	public void init() {
		profileService = new ProfileServiceImpl(profileDao, profileMapper);
	}

	@Test
	public void testRead() throws InvalidProfileException {
		// Simulate InvalidProfileException
		try {
			profileService.read("");
			fail(); // should never execute
		}
		catch (InvalidProfileException e) {
			e.getMessage(); // expected
		}

		// Given
		Profile profile = TestData.createTestProfile("userid"); // test utility to create a test Profile
		when(profileDao.read("userid")).thenReturn(profile);
		when(profileMapper.fromEntity(profile )).thenReturn(TestData.createTestProfileDto("userid"));

		// When
		ProfileDto dto = profileService.read("userid");

		// Then
		assertEquals(dto.getUserId(), "userid");
	}
}

Explanation:
1) Wrapping your test with @RunWith(MockitoJUnitRunner.class) helps create the mock initialization through annotation scanning (@Mock, @InjectMocks)
2) Add @Mock annotations for the components to mock. In this case profileDao, profileMapper
3) As of 1.8.5, Mockito doesn’t provide @InjectMock with construction injection. @Before test initializer is a workaround to inject ProfileService with mocks. Note that this will not be required if ProfileService has setter/getter injection of dependencies. However, I prefer JSR330 construction injection which is a best practice .
4) The actual @Test class with mockito stubs. Let’s dig deep into this.

As a template, it’s a good practice to view tests like a BDD style test.

// Given 

// When

// Then

The above template forces you to think on the explicit conditions during which we run our unit test.

Next, we need to figure out a way to stub our mock component’s methods,

when(operation).thenReturn(object)

In our example we want to mock profileDao.read(userId). So that translates to

when(profileDao.read("userid")).thenReturn(profile);

Note that we’re letting the mocked dao return a profile object that we just created in the previous step. This will be 50% of most of your mocking use cases.

The next common used use case is to simulate exceptions from the mocked classes. Consider a test for create(…) that simulates the DuplicateProfileException.

@Test
	public void testCreateDuplicate() {
		// Given
		ProfileDto dto = TestData.createTestProfileDto("userid");
		Profile profile = TestData.createTestProfile("userid");
		when(profileMapper.toEntity(dto)).thenReturn(profile);
		doThrow(new DuplicateKeyException("duplicate profile")).when(profileDao).save(profile);

		// When
		try {
			profileService.create(dto);
			assertEquals(1, 2); // should never execute
		}
		// Then
		catch (DuplicateProfileException e) {
			e.getMessage();
		}
	}

Notice the line

doThrow(new DuplicateKeyException("duplicate profile")).when(profileDao).save(profile);

Quite simple, isn’t it?

If you’ve read so far, you can succuessfully write mock unit tests for 80% of your use cases. There are other advanced features like finding redundant invocations, spying on objects to simulate partial mocking, most of which I don’t see implementing for majority of my use cases.

- Two types of transactions: Global and Local Transactions
- PlatformTransactionManager is main interface in Spring
- PROPAGATION_REQUIRED, PROPAGATION_SUPPORTS, PROPAGATION_MANDATORY, PROPAGATION_REQUIRES_NEW, PROPAGATION_NOT_SUPPORTED, PROPAGATION_NEVER, PROPAGATION_NESTED
- ISOLATION_DEFAULT, ISOLATION_READ_UNCOMMITTED, ISOLATION_READ_COMMITTED, ISOLATION_REPEATABLE_READ, ISOLATION_SERIALIZABLE
- Spring’s Declarative Transaction management. Can customize transactional behavior using AOP. Like custom behavior in case
of transaction rollback declaritvely.
- How @Transactional works. The combination of AOP with transactional metadata yields an AOP proxy that uses a TransactionInterceptor in conjunction with an appropriate PlatformTransactionManager implementation to drive transactions around method invocations

- Steps when a method is invoked with @Transactional
— Spring AOP kicks in, create proxy of the target. If nothing is configured JDDK dynamic proxy is created, but if aspectj is configured,
aspectJ proxy is created
— TransactionInterceptor kicks in the configured TransactionAdvice
— TransactionAdvice calls the underlying PlatformTransactionManager to acquire a new db connection
— Datasource is kicked in. If a connection pool is present, a conection is returned from the pool
— Method is invoked
— If no exceptions, great
— If exceptions are returned, apply rules to determine whether transaction should be rolled back. If yes, TransactionInterceptor will roll back
transaction
— Based on exceptions, PlatformTransactionManager either commits or rollsback transaction
— Release connection JDBC after transaction
— Return conenction to pool
— Return the method call

- Annotate @Transactional on classes and not interfaces because Java annotations are not inherited from interfaces means that if you are using class-based proxies or the weaving-based aspect then the transaction settings are not recognized by the proxying and weaving infrastructure, and the object will not be wrapped in a transactional proxy.

- When using proxies, you should apply the @Transactional annotation only to methods with public visibility.

- Spring AOP uses either JDK dynamic proxies or CGLIB to create the proxy for a given target object. If the target object to be proxied implements at least one interface then a JDK dynamic proxy will be used. If the target object does not implement any interfaces then a CGLIB proxy will be created.

- Using ‘proxy-target-class=”true”‘ on , or elements will force the use of CGLIB proxies for all three of them.

- multiple transaction managers can be used and referred as @Transactional (“account”)

<bean id="transactionManager1" class="org.springframework.jdbc.DataSourceTransactionManager">
    ...
   <qualifier value="account"/>
</bean>

- Programmatic transaction can be done by TransactionTemplate (callBack approach) or PlatformTransactionManager directly

JPA
—

<!-- Activates @PersistentContext -->
<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />

References:
Spring Transaction Propogation
Stack Overflow “transactions”
Transactional Pitfalls

I’ve modified the spring security config file and will be unit testing a simple ProfileService (CRUD) on a Profile entity (User object). The tests include login/logout and spring services security unit testing.

application-security.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans:beans
    xmlns="http://www.springframework.org/schema/security"
    xmlns:beans="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/security

http://www.springframework.org/schema/security/spring-security-3.0.xsd">

	<global-method-security pre-post-annotations="enabled"/>

	<http use-expressions="true">
		<intercept-url pattern="/secure/extreme/**" access="hasRole('ROLE_SUPERVISOR')"/>
		<intercept-url pattern="/secure/**" access="isAuthenticated()" />
		<intercept-url pattern="/**" access="permitAll" />
		<form-login />
		<logout />
		<remember-me />

		<!-- Uncomment to limit the number of sessions a user can have -->
		<session-management invalid-session-url="/timeout.jsp">
			<concurrency-control max-sessions="1" error-if-maximum-exceeded="true" />
		</session-management>
	</http>

	<authentication-manager>
		<authentication-provider>
			<!--  <password-encoder hash="md5"/> -->
			<user-service>
				<user name="admin" password="admin" authorities="ROLE_ADMIN, ROLE_USER" />
				<user name="user" password="user" authorities="ROLE_USER" />
				<user name="reports" password="reports" authorities="ROLE_REPORTS" />
			</user-service>
		</authentication-provider>
	</authentication-manager>	

</beans:beans>

Base DB Unit Test with utils for Spring Security

import java.io.FileInputStream;
import java.sql.Connection;
import javax.inject.Inject;
import javax.sql.DataSource;
import org.apache.log4j.Logger;
import org.dbunit.database.*;
import org.dbunit.operation.DatabaseOperation;
import org.springframework.jdbc.datasource.DataSourceUtils;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.test.context.transaction.*;

/**
 * Base Test that wraps a DbUnit style Test case by inserting a sample testdata
 * on startup. Provides necessary functions to login/logout, add roles, etc
 */
public abstract class BaseSecurityTest {

	private static final Logger logger = Logger
			.getLogger(BaseSecurityTest.class);

	Connection con;
	IDatabaseConnection dbUnitCon;
	IDataSet dataSet;

	@Inject
	private DataSource dataSource;

	protected abstract String getTestClassname();

	@BeforeTransaction
	public void beforeTx() throws Exception {
		logger.debug("Opening Db Connection ... ");
		con = DataSourceUtils.getConnection(dataSource);
		dbUnitCon = new DatabaseConnection(con);
		dataSet = getDataSet(getTestClassname());

		DatabaseOperation.CLEAN_INSERT.execute(dbUnitCon, dataSet);
	}

	@AfterTransaction
	public void afterTx() throws Exception {
		logger.debug("Releasing Db Connection ...");
		DataSourceUtils.releaseConnection(con, dataSource);
	}

	protected IDataSet getDataSet(String name) throws Exception {
		return new FlatXmlDataSetBuilder().build(new FileInputStream(
				"src/test/resources/" + name + ".xml"));
	}

	protected void clearContext() {
		SecurityContextHolder.clearContext();
	}

	protected void login(String username, String password) {
		SecurityContextHolder.getContext().setAuthentication(
				new UsernamePasswordAuthenticationToken(username, password));

		logger.debug("User:" + username + " logged in");
	}

	protected String getLoginDetails() {
		Object principal = SecurityContextHolder.getContext()
				.getAuthentication().getPrincipal();

		if (principal instanceof UserDetails) {
			return ((UserDetails)principal).getUsername();
		}
		else {
			return principal.toString();
		}

	}
}

ProfileServiceTest

import static org.junit.Assert.assertEquals;
import java.util.List;
import javax.inject.Inject;
import org.apache.log4j.Logger;
import xxx.Profile;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;
import org.springframework.transaction.annotation.Transactional;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
		"classpath*:spring/applicationContext-core.xml",
		"classpath*:spring/applicationContext-mail.xml",
		"classpath*:spring/applicationContext-security.xml" })
@TransactionConfiguration
@Transactional
public class ProfileServiceTest extends BaseSecurityTest {

	private static final Logger logger = Logger
			.getLogger(ProfileServiceTest.class);

	@Inject
	private ProfileService profileService;

	@Override
	protected String getTestClassname() {
		return "ProfileServiceTest";
	}

	@Test
	public void testUserLogin() {
		login("admin", "admin");
		String username = getLoginDetails();
		assertEquals(username, "admin");

		login("user", "user");
		String username2 = getLoginDetails();
		assertEquals(username2, "user");

		login("reports", "reports");
		String username3 = getLoginDetails();
		assertEquals(username3, "reports");
	}

	@Test
	public void testRead() {

		// Test with role that has access to the service
		login("user", "user");
		profileService.read("1");

		login("reports", "reports");
		profileService.read("1");

		// Test with role that doesn't have access to the service
		login("admin", "admin");
		try {
			profileService.read("1");
		}
		catch (AccessDeniedException e) {
			// Expected
			assert(true);
			return;
		}

		// it should not reach here
		assert(false);
	}

	@Test
	public void testFindProfiles() {
		List<Profile> list = profileService.FindProfiles();
		assertEquals(4, list.size());
	}

	@Test
	public void testFindProfileById() {
		List<Profile> list = profileService.findProfileById("123");
		assertEquals(1, list.size());
	}

	@Test
	public void testSave() {

		// Test with role that has access to the service
		login("admin", "admin");
		Profile dummy = new Profile();
		profileService.save(dummy);		

		// Test with role that doesn't have access to the service
		login("reports", "reports");
		try {
			profileService.save(dummy);
		}
		catch (AccessDeniedException e) {
			// Expected
			assert(true);
			return;
		}

		// it should not reach here
		assert(false);
	}
}

The Profile Service

public interface ProfileService {

	@PreAuthorize("hasRole('ROLE_USER') or hasRole('ROLE_REPORTS')")
	Profile read(String id);

	List<Profile> findProfiles();

	List<Profile> findProfileById(String Id);

	@PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_USER')")
	Profile save(Profile account);

	@PreAuthorize("hasRole('ROLE_ADMIN')")
	void delete();

}

Here’s an example demonstrating a custom logout handler using Spring 3 security module. The code has some incompatibility issues with Spring 2 as Spring 3 Security is not 100% backward compatibility.

Sample User

public class User extends org.springframework.security.core.userdetails.User {
 // Stuff
}

Custom Filter Handler

import java.io.IOException;

import javax.annotation.PostConstruct;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.security.core.Authentication;
import org.springframework.security.web.DefaultRedirectStrategy;
import org.springframework.security.web.RedirectStrategy;
import org.springframework.security.web.authentication.logout.LogoutFilter;
import org.springframework.security.web.authentication.logout.LogoutHandler;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;
import org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler;

import xxx.model.User;

public class LogoutFilterWrapper
	implements Filter {

	private String logoutSuccessfulUrl;

	private String logoutSuccessfulUrlAdmin;

	private String logoutSuccessfulInactivityUrl;

	private LogoutFilter filter;

	@PostConstruct
	protected void initialize() {

		final SecurityContextLogoutHandler context = new SecurityContextLogoutHandler();
		context.setInvalidateHttpSession( true );
		this.filter =
			new LogoutFilter( new CustomLogoutSuccessHandler(), new LogoutHandler[] { context } );
	}

	public void setLogoutSuccessfulUrl(
		String inUrl ) {

		this.logoutSuccessfulUrl = inUrl;
	}

	public void setLogoutSuccessfulUrlAdmin(
		String inUrl ) {

		this.logoutSuccessfulUrlAdmin = inUrl;
	}

	public void setLogoutSuccessfulUrlInactivity(
		String inUrl ) {

		this.logoutSuccessfulInactivityUrl = inUrl;
	}

	public final void init(
		FilterConfig inFilterConfig )
		throws ServletException {

		this.filter.init( inFilterConfig );
	}

	public final void destroy() {

		this.filter.destroy();
	}

	public final void doFilter(
		ServletRequest inRequest,
		ServletResponse inResponse,
		FilterChain inChain )
		throws IOException, ServletException {

		this.filter.doFilter( inRequest, inResponse, inChain );
	}

	/**
	 * Success Handler
	 */
	private class CustomLogoutSuccessHandler
		implements LogoutSuccessHandler {

		private RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();

		@Override
		public void onLogoutSuccess(
			HttpServletRequest request,
			HttpServletResponse response,
			Authentication authentication )
			throws IOException, ServletException {

			String targetUrl = "";
			User principal = null;

			if ( authentication != null ) {
				if ( !(authentication.getPrincipal() instanceof User) ) {
					throw new IllegalArgumentException( "Invalid security principal type!" );
				}
				principal = (User) authentication.getPrincipal();
			}

			if ( principal == null ) {
				throw new IllegalStateException( "Security principal is not initialized!" );
			}

			final String loginUrl =
				principal.isAdministrator() ? LogoutFilterWrapper.this.logoutSuccessfulUrlAdmin
					: LogoutFilterWrapper.this.logoutSuccessfulUrl;

			final String timeoutUrl =
				LogoutFilterWrapper.this.logoutSuccessfulInactivityUrl
					+ "?login="
					+ request.getContextPath()
					+ loginUrl;

			targetUrl = request.getQueryString().contains( "timeout=true" ) ? timeoutUrl : loginUrl;

			redirectStrategy.sendRedirect( request, response, targetUrl );
		}
	}
}

Spring-config

<!-- Register a custom logout filter -->
<beans:bean id="customLogoutFilter" class="com.cramer.srf.security.LogoutFilterWrapper">
    <beans:property name="logoutSuccessfulUrl" value="/public/auth/login.htmlx" />
    <beans:property name="logoutSuccessfulUrlAdmin" value="/public/auth/admlogin.htmlx" />
    <beans:property name="logoutSuccessfulUrlInactivity" value="/public/auth/timedout.htmlx" />
</beans:bean>

Before using this, you should’ve designed your domain model to extend a Base Class (do it, it’s a good practice). In my case, I have BaseIdentityEntity which has an @Id, @Version properties

import java.io.Serializable;

import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.convert.Converter;
import javax.faces.convert.ConverterException;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.apache.log4j.Logger;
import org.springframework.stereotype.Service;

import xxx.model.BaseIdentityEntity;

/**
* Generic Entity Converter for any Entity that extends BaseIdentityEntity
*
*/
@Service("entityConverter")
public class EntityConverter implements Converter, Serializable {
	static Logger log = Logger.getLogger(EntityConverter.class);
	private static final long serialVersionUID = -5137676309479323480L;

	@PersistenceContext
	protected EntityManager entityManager;

	@SuppressWarnings("unchecked")
	public Object getAsObject(FacesContext facesContext, UIComponent component,
			String value) throws ConverterException {
		BaseIdentityEntity entity;
		if (value == null) {
			entity = null;
		} else {
			Integer id = new Integer(value);
			entity = (BaseIdentityEntity) entityManager.find(getClazz(
					facesContext, component), id);
			if (entity == null) {
				log.debug("There is no entity with id:  " + id);
				//throw new IllegalArgumentException("There is no entity with id:  " + id);
			}
		}
		return entity;
	}

	public String getAsString(FacesContext facesContext, UIComponent component,
			Object value) throws ConverterException {
		if (value != null && !(value instanceof BaseIdentityEntity)) {
			throw new IllegalArgumentException(
					"This converter only handles instances of BaseIdentityEntity");
		}
		if (value == null) {
			return "";
		}
		if (value instanceof String) {
			return (String) value;
		}
		BaseIdentityEntity entity = (BaseIdentityEntity) value;
		return entity.getId() == null ? "" : entity.getId().toString();
	}

	// Gets the class corresponding to the context in jsf page
	@SuppressWarnings("unchecked")
	private Class getClazz(FacesContext facesContext, UIComponent component) {
		return component.getValueExpression("value").getType(facesContext.getELContext());
	}

}

You don’t have to add any configuration in the taglibs since Spring’s @Service tag makes the converter a managed bean and you can reference it directly in jsf.

Usage: (Using JSF tomahawk here, but works for any jsf component library)

<h:selectOneMenu value="#{mycontroller.foo}" converter="#{enumConverter}">
	<h:selectItems value="#{mycontroller.foos}" var="element"
	itemLabel="#{element}" itemValue="#{element}" />
</h:selectOneMenu>

With a brief introduction on Spring, an overview of Spring Integration was covered, the 1.0 version of which is due in a couple of months from now (latest is 1.0 Milestone 5). I haven’t coded on JMS Messaging or worked on any of the open source EAI/ESB infrastructure for a long time, so I’ll keep this post relatively small.

If you’re familiar with EAI Patterns, and have been using Spring for a while, Spring Integration should feel like a breeze, a clean API working around already known concepts — Message, Message Channel, Endpoint, Pipes & Filters, you get the drift. A much simpler model compared to existing proprietary approaches. Read the goals and principles. Spring’s annotation approach to wire end points, a router or even a splitter is pretty cool when combined with Spring’s Component Scanner annotation. The recent release also includes several default adapters included (Source and target implementations for JMS, Files, Streams, and Spring ApplicationEvents.)

For a deeper understanding and hand’s on code, I’d recommend, go through the Cafe Sample. It’s quite self explainatory and is easy to implement one.

On a last note, I think “Spring Integration” is a such a confusing name. A google search results in all other integration results, not necessarily Spring’s EAI. “integration”. Perhaps it should have been named Spring EAI for simplicity sake.

Resources:-

EAI Patterns home
Greg’s Ramblings
EAI Wiki
Open source EAI Tools

What do you do then?

Welcome to Schemamule. It’s a tiny jar file and has a single ant task which copies the entire Oracle Schema and generates a Hsqldb database. YES. It replicates an entire Oracle Schema into a hsqldb in seconds! You can either use it as an in memory database for your automated unit testing or as dev only local database for unit testing. For more details, read the original blog here.

Let me iterate the advantages:-

– Can write database dependent test cases
– Need not connect to a network for running tests
– Database tests run at blazing speed, as now they’re on hsqldb

I worked with one of the developers — Rhett Sutphin, in my earlier project. He’s a brilliant programmer. I’ve also reused it in one of my projects at a financial firm, it works great and is amazingly productive once you have setup a framework based on dbunit. Wait, what is dbunit? I’m not going into the details but it’s a no-brainer that if you use hibernate and junit, you better get started on using dbunit for unit testing backed by xml datasets instead of the cumbersome setup/teardown methods to populate data for each junit test case

We have a sample project checked into RTC’s sourceforge (We call it helloworld2), with custom classes on top of DBUnit (most of it has been written by the author of Schemamule).

My example considers of an entity, Foo with FooDao, mapped to a table Foo. For simplicity, I assume one field called name. As a step by step tutorial on extending DBUnit Unit Testing , I’ll show how simple it is to write a Dao based unit test case using Dbunit, Spring and Hibernate (of course on our generated hsqldb)

Step 1:Create an Hsqldb database from Oracle

Download Schemamule and run the following ant task

<schemacopy xmlns="http://bioinformatics.northwestern.edu/schemamule">
    <to uri="jdbc:hsqldb:file:${basedir}/hsqldb/mydb" username="sa">
    <from uri="jdbc:oracle:thin:mydb" username="scott" password="tiger">
</from>
</to></schemacopy>

Step 2: Setup DBUnit
Download the latest version of dbunit (jdk1.4 or jdk5)

Step 3: Download the svn repository (0r copy by browsing svn) Revert To Console’s sample test utility classes and example DBUnit tutorial from sourceforge here.

- Checkout under projects/unit-test.
- I’m not providing a complete working example with spring/hibernate configuration, as I presume you are running under an environment where you already have a this configured with an Oracle database.

- the utility classes include the following classes
- CoreTestCase — An extension on JUnit with much more useful assert statements
- ApplicationTestCase — All the unit tests in your Spring/Hibernate project should extend this class
- DaoTestCase — All your Dao Tests should extend this class
- ContextTools – The class which reads your applicationContext-xyz.xml file, where hibernate session is configured
- Sample Dao and entity

Configure these files in your project, which can read the applicationContext from the classpath (for the tests to work!)

Step 4:With all this configured, let’s write a simple Dao Test

public class FooDAOTest extends DaoTestCase {
    FooDao dao = (FooDao)getApplicationContext().getBean("fooDao");
         // assuming that your spring config has a bean-id 'fooDao'
	 public void testGetById() throws Exception {
            Foo foo = (Foo)dao.getById(1);
            assertEquals("revert to console", foo.getName());
	 }
}

By Default, DBUnit assumes a test data xml file in the same testdata/FooDaoTest.xml (you can override this). Now, lets see the dataset

<dataset>
<table name="FOO"><column>name</column>
        <row>
            <value>revert to console</value>
         </row></table>
</dataset>

That’s it! For all the configuration that I’ve showed you (which will take some time to setup), all you need to do to write another test is, to write another method with testdata! This setup will create,drop the testdata on the generated HsqlDb schema before/after each test. What more, because, it is in memory, you can even run, Dao Tests and complete round trip unit tests automated in your nightly builds, without coupling to an existing Oracle Schema.

There are some limitations to Schemamule though. I had to customize it for my project as we were using DB Views. I finally got it working after modifying the sourcecode. Unfortunately I could never put that back into Schemamule as a patch but I recommend downloading the source and try it for yourself. It’s a great example on understanding how Spring’s Jdbc template works and can be extended.

	@Override
	protected void buildExcelDocument(Map model, HSSFWorkbook workbook,
			HttpServletRequest req, HttpServletResponse resp) throws Exception {

	    //CREATE THE SHEET
		String periodDate = (String)model.get(PAYROLL_PERIOD_KEY);
	    HSSFSheet sheet = workbook.createSheet(periodDate);
	    sheet.setDefaultColumnWidth((short) 12);

	    //GETCELL: getCell(SHEET, ROW, COLUMN);
	    short currentRow = 0;

	    //WRITE ROW FOR HEADER
	    HSSFCell header0 = getCell(sheet, currentRow, NAME_COLUMN);
	    setText(header0, "NAME");

	    HSSFCell header1 = getCell(sheet, currentRow, TOTAL_BILLABLE_COLUMN);
	    setText(header1, "TOTAL BILLABLE");

	    HSSFCell header2 = getCell(sheet, currentRow, OVERTIME_COLUMN);
	    setText(header2, "OVERTIME");

	    HSSFCell header3 = getCell(sheet, currentRow, SUPPORT_COLUMN);
	    setText(header3, "SUPPORT");

	    HSSFCell header4 = getCell(sheet, currentRow, VACATION_COLUMN);
	    setText(header4, "VACATION");

	    HSSFCell header5 = getCell(sheet, currentRow, SICK_COLUMN);
	    setText(header5, "SICK");

	    Collection<payrollReportConsultantDisplay> timesheetList =
	    	(Collection<payrollReportConsultantDisplay>) model.get(PAYROLL_LIST_KEY);

	    Iterator<payrollReportConsultantDisplay> timesheetIterator = timesheetList.iterator();
	    while (timesheetIterator.hasNext())  {
	      currentRow++;
	      PayrollReportConsultantDisplay timesheet = timesheetIterator.next();
	      HSSFRow row = sheet.createRow(currentRow);
	      row.createCell(NAME_COLUMN).setCellValue(
	    		  new HSSFRichTextString(timesheet.getDisplayName()));
	      if(StringUtils.isNotEmpty(timesheet.getTotalBillableHours())) {
		      row.createCell(TOTAL_BILLABLE_COLUMN).setCellValue(
		    		  new Double(timesheet.getTotalBillableHours()).doubleValue());
	      }
	      if(StringUtils.isNotEmpty(timesheet.getOvertimeHours())) {
		      row.createCell(OVERTIME_COLUMN).setCellValue(
		    		  new Double(timesheet.getOvertimeHours()).doubleValue());
	      }
	      if(StringUtils.isNotEmpty(timesheet.getInternalSupportHours())) {
		      row.createCell(SUPPORT_COLUMN).setCellValue(
		    		  new Double(timesheet.getInternalSupportHours()).doubleValue());
	      }
	      if(StringUtils.isNotEmpty(timesheet.getVacationHours())) {
		      row.createCell(VACATION_COLUMN).setCellValue(
		    		  new Double(timesheet.getVacationHours()).doubleValue());
	      }
	      if(StringUtils.isNotEmpty(timesheet.getSickHours())) {
		      row.createCell(SICK_COLUMN).setCellValue(
		    		  new Double(timesheet.getSickHours()).doubleValue());
	      }
	    }
            //Provide a formula for totals
	    HSSFRow row = sheet.createRow(++currentRow);
	    row.createCell(NAME_COLUMN).setCellValue(new HSSFRichTextString("Totals:"));
	    row.createCell(TOTAL_BILLABLE_COLUMN).setCellFormula("SUM(B1:B" + (currentRow -1) + ")");
	    row.createCell(OVERTIME_COLUMN).setCellFormula("SUM(C1:C" + (currentRow -1) + ")");
	    row.createCell(SUPPORT_COLUMN).setCellFormula("SUM(D1:D" + (currentRow -1) + ")");
	    row.createCell(VACATION_COLUMN).setCellFormula("SUM(E1:E" + (currentRow -1) + ")");
	    row.createCell(SICK_COLUMN).setCellFormula("SUM(F1:F" + (currentRow -1) + ")");
	}

Hat tip to Zabada Technologies.
Hat tip to softartisans.

Your unit test extends AbstractTransactionalDataSourceSpringContextTests, and makes use of autowiring.

You write your test, run it, and receive something like this:

 Unsatisfied dependency expressed through bean property 'aController':
 No unique bean of type [org.reverttoconsole.majorapplication.controller.aController] is defined:
  expected single matching bean but found 2: [aController.htm, bController.htm]

I tried using annotations, using @Autowire and @Resource, but in the end had to refactor my code to fit the tests… by creating an Abstract class that both controllers could extend.

In my application there is basically one table for all users. It contains the values I need for username, password, role, and the active flag that Spring Security supports. No, it wouldn’t be my first choice of table setup, but that’s what I have to work with.

I read through Chris Baker’s fine article in the Java DZONE and the way he did it was to override two values in the jdbc-user-service, which replaces the user-service authentication provider. He used:

<authentication-provider>
	<jdbc-user-service data-source-ref="dataSource"
	users-by-username-query="SELECT U.username, U.password, U.accountEnabled AS 'enabled' FROM User U where U.username=?"
	authorities-by-username-query="SELECT U.username, R.name as 'authority' FROM User U JOIN Authority A ON u.id = A.userId JOIN Role R ON R.id = A.roleId WHERE U.username=?"/>
</authentication-provider>

I wanted to do something similar, and initially banged out:

	<authentication-provider>
	<jdbc-user-service data-source-ref="baseDataSource"
	users-by-username-query="SELECT LOGONID, PASSWORD, ACTIVE FROM EMPLOYEE WHERE LOGONID=?"
	authorities-by-username-query="SELECT LOGONID, ROLE FROM EMPLOYEE WHERE LOGONID=?"/>
	</authentication-provider>

The result was that all employees were inactive for Spring Security. Why? Because the EMPLOYEE table’s ACTIVE column is a CHAR, and Spring Security expects a BIT or BOOLEAN. After tinkering around for a bit, I decided to modify the EMPLOYEE table to use a BOOLEAN instead. The actually posed a problem for DbUnit, surprise surprise. The workaround in Ant didn’t work for me, I had a weird classnotfound error that I couldn’t track back to ant, and just gave up after a while. I didn’t really want to change the column type anyway.

In the end, I played around with HSQL for a while and came up with

	<authentication-provider>
	<jdbc-user-service data-source-ref="baseDataSource"
	users-by-username-query="SELECT LOGONID, PASSWORD, CASE WHEN UCASE(ACTIVE)='T' THEN 1 ELSE 0 END FROM EMPLOYEE WHERE LOGONID=?"
	authorities-by-username-query="SELECT LOGONID, ROLE FROM EMPLOYEE WHERE LOGONID=?"/>
	</authentication-provider>

Disclaimer: There are other ways to do this that are identified in the Spring Security reference documentation. The documentation is very good, my only wish would be that they provide the default schema, and provide a description of the default roles.