Testing Spring applications

In my last post we talked about Spring. As a test infected developer, my commitment is to test as much as I can to be sure in quality of my code. So, is it feasible to test (and how?) applications which heavily use Spring? The answers are: yes and very easy with help of Spring testing framework. We will consider a few basic scenarios with testing simple Spring beans and then touch a little bit context-related issues.

So. let's start with Spring beans under the test. I prefer to use Java 5 and annotations to publish regular POJOs as Spring beans and declare dependency injection between beans as well. The bean will be MessageService as in code snippet below:

package com.krankenhouse.services;

@Component
public class MessageService {
  @Autowired private ITransport impl;
  @Autowired private ILogger logger;

  public void send( final String message ) {   
      logger.log( message );
      impl.send( message );
  }

  public String receive() {
      final String message = impl.receive();
      logger.log( message );
      return message;
  }
}

This bean is pretty simple and just demonstrates two important concepts: exporting POJO as Spring bean (@Component) and using dependency injection (@Autowired). Before diving into how to test it, let's create applicationContext.xml (placed inside WEB-INF folder) file.

<?xml version="1.0" encoding="UTF-8"?>
<beans
   xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-2.5.xsd">
  
       <context:annotation-config/>
       <context:component-scan base-package="com.krankenhouse.services" />
</beans>

OK, now we're ready to write our first test, named MessageServiceTestCase. There are basically several ways to do that, depending which features do you need. The first one looks like:

package com.krankenhouse.services;

@RunWith( SpringJUnit4ClassRunner.class )
@ContextConfiguration( locations = {
       "classpath:/META-INF/applicationContext.xml"
   }
)
public class MessageServiceTestCase {
   @Autowired private MessageService messageService;
  
   public void testSend() {
       messageService.send( "Message" );
   }   
}

And that's it! Spring takes care about context initialization, beans creation, dependency injection, etc. If you need application context inside the test, then a little bit different approach could be used (by inheriting test class from AbstractJUnit4SpringContextTests class):

package com.krankenhouse.services;

@RunWith( SpringJUnit4ClassRunner.class )
@ContextConfiguration( locations = {
       "classpath:/META-INF/applicationContext.xml"
   }
)
public class MessageServiceTestCase
       extends AbstractJUnit4SpringContextTests {
   public void testSend() {
       MessageService messageService =
           ( MessageService )applicationContext
               .getBean( "messageService");
       messageService.send( "Message" );
   }   
}

There's one important issue concerning Spring context: only one context will be created for each test class instance (not test method!). If you would like to recreate context for each single test method, you have to adorn these ones with @DirtiesContext annotation. Unfortunately, there is no class-level annotation for that up to 2.5.x versions.

In spring with Spring ...

Today I'm going to talk a little bit about Spring. Unfortunately, I didn't use heavily this great framework so far. And that's my fault. Spring is definitely worth to learn and use. Beforehand I would like to recommend an excellent book Pro Spring 2.5 which gave me good start in using Spring.

So, why Spring? Over the years I've been developing software pursuing the same principles: good and clever design, simplicity (keep it simple but not simpler), and easy configuration. In our object-oriented programming era it's all about objects. How simple are relations (dependencies) between objects, how loosely coupled are modules/subsystems/objects, how painful is deployment? And are you able to cover with unit tests each piece of critical functionality (you definitely must do that)?

Spring definitely helps with solving all those issues. Its core is dependency injection container which allows to inject dependencies in declarative manner (either in XML configuration or using Java 5 annotations). And a bunch of additional modules provides everything you need from AOP to JUnit support in order to develop high-quality JEE applications.