The org.springframework.mock.jndi package contains an implementation of the JNDI SPI, which you can use to set up a simple JNDI environment for test suites or stand-alone applications. If, for example, JDBC DataSources get bound to the same JNDI names in test code as within a Java EE container, you can reuse both application code and configuration in testing scenarios without modification.

The org.springframework.mock.web package contains a comprehensive set of Servlet API mock objects, targeted at usage with Spring's Web MVC framework, which are useful for testing web contexts and controllers. These mock objects are generally more convenient to use than dynamic mock objects such as EasyMock or existing Servlet API mock objects such as MockObjects.

The org.springframework.mock.web.portlet package contains a set of Portlet API mock objects, targeted at usage with Spring's Portlet MVC framework.

The org.springframework.test.util package contains ReflectionTestUtils, which is a collection of reflection-based utility methods. Developers use these methods in unit and integration testing scenarios in which they need to set a non-public field or invoke a non-public setter method when testing application code involving, for example:

The org.springframework.test.web package contains ModelAndViewAssert, which you can use in combination with JUnit 4+, TestNG, and so on for unit tests dealing with Spring MVC ModelAndView objects.

	Unit testing Spring MVC Controllers
	To test your Spring MVC Controllers, use ModelAndViewAssert combined with MockHttpServletRequest, MockHttpSession, and so on from the org.springframework.mock.web package.

The Spring TestContext Framework provides consistent loading of Spring ApplicationContexts and caching of those contexts. Support for the caching of loaded contexts is important, because startup time can become an issue - not because of the overhead of Spring itself, but because the objects instantiated by the Spring container take time to instantiate. For example, a project with 50 to 100 Hibernate mapping files might take 10 to 20 seconds to load the mapping files, and incurring that cost before running every test in every test fixture leads to slower overall test runs that could reduce productivity.

Test classes provide an array containing the resource locations of XML configuration metadata - typically in the classpath - that is used to configure the application. These locations are the same as or similar to the list of configuration locations specified in web.xml or other deployment configuration files.

By default, once loaded, the configured ApplicationContext is reused for each test. Thus the setup cost is incurred only once (per test fixture), and subsequent test execution is much faster. In the unlikely case that a test corrupts the application context and requires reloading -- for example, by changing a bean definition or the state of an application object-- a Spring testing support mechanism causes the test fixture to reload the configurations and rebuilds the application context before executing the next test.

See context management and caching with the TestContext Framework.

When the TestContext framework loads your application context, it can optionally configure instances of your test classes via Dependency Injection. This provides a convenient mechanism for setting up test fixtures using preconfigured beans from your application context. A strong benefit here is that you can reuse application contexts across various testing scenarios (e.g., for configuring Spring-managed object graphs, transactional proxies, DataSources, etc.), thus avoiding the need to duplicate complex test fixture set up for individual test cases.

As an example, consider the scenario where we have a class, HibernateTitleDao, that performs data access logic for say, the Title domain object. We want to write integration tests that test all of the following areas:

See: dependency injection of test fixtures with the TestContext Framework.

One common issue in tests that access a real database is their affect on the state of the persistence store. Even when you're using a development database, changes to the state may affect future tests. Also, many operations - such as inserting or modifying persistent data - cannot be performed (or verified) outside a transaction.

The TestContext framework addresses this issue. By default, the framework will create and roll back a transaction for each test. You simply write code that can assume the existence of a transaction. If you call transactionally proxied objects in your tests, they will behave correctly, according to their transactional semantics. In addition, if test methods delete the contents of selected tables while running within a transaction, the transaction will roll back by default, and the database will return to its state prior to execution of the test. Transactional support is provided to your test class via a PlatformTransactionManager bean defined in the test's application context.

If you want a transaction to commit - unusual, but occasionally useful when you want a particular test to populate or modify the database - the TestContext framework can be instructed to cause the transaction to commit instead of roll back via the @TransactionConfiguration and @Rollback annotations.

See transaction management with the TestContext Framework.

The Spring TestContext Framework provides several abstract support classes that simplify the writing of integration tests. These base test classes provide well-defined hooks into the testing framework as well as convenient instance variables and methods, which enable you to access:

In addition, you may want to create your own custom, application-wide superclass with instance variables and methods specific to your project.

See support classes for the TestContext Framework.

The core of the framework consists of the TestContext and TestContextManager classes and the TestExecutionListener interface. A TestContextManager is created on a per-test basis. The TestContextManager in turn manages a TestContext that holds the context of the current test. The TestContextManager also updates the state of the TestContext as the test progresses and delegates to TestExecutionListeners, which instrument the actual test execution, by providing dependency injection, managing transactions, and so on. Consult the JavaDoc and the Spring test suite for further information and examples of various configurations.

The following three sections explain how to configure the TestContext framework through annotations and provide working examples of how to write unit and integration tests with the framework.

Each TestContext provides context management and caching support for the test instance for which it is responsible. Test instances do not automatically receive access to the configured ApplicationContext. However, if a test class implements the ApplicationContextAware interface, a reference to the ApplicationContext is supplied to the test instance, if the DependencyInjectionTestExecutionListener is configured, which is the default. AbstractJUnit38SpringContextTests, AbstractJUnit4SpringContextTests, and AbstractTestNGSpringContextTests already implement ApplicationContextAware and therefore provide this functionality out-of-the-box.

	@Autowired ApplicationContext
	As an alternative to implementing the ApplicationContextAware interface, you can inject the application context for your test class through the @Autowired annotation on either a field or setter method. For example: @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration public class MyTest { @Autowired private ApplicationContext applicationContext; // class body... }

In contrast to the now deprecated JUnit 3.8 legacy class hierarchy, test classes that use the TestContext framework do not need to override any protected instance methods to configure their application context. Rather, configuration is achieved merely by declaring the @ContextConfiguration annotation at the class level. If your test class does not explicitly declare application context resource locations, the configured ContextLoader determines how and whether to load a context from a default set of locations. For example, GenericXmlContextLoader , which is the default ContextLoader, generates a default location based on the name of the test class. If your class is named com.example.MyTest, GenericXmlContextLoader loads your application context from "classpath:/com/example/MyTest-context.xml".

package com.example;

@RunWith(SpringJUnit4ClassRunner.class)
// ApplicationContext will be loaded from "classpath:/com/example/MyTest-context.xml"
@ContextConfiguration
public class MyTest {
    // class body...
}

If the default location does not suit your needs, you can configure explicitly the locations attribute of @ContextConfiguration with an array that contains the resource locations of XML configuration metadata (assuming an XML-capable ContextLoader has been configured) - typically in the classpath - used to configure the application. (See the following code example.) This location will be the same, or nearly the same, as the list of configuration locations specified in web.xml or other deployment configuration. Alternatively, you can implement and configure your own custom ContextLoader.

@RunWith(SpringJUnit4ClassRunner.class)
// ApplicationContext will be loaded from "/applicationContext.xml" and "/applicationContext-test.xml"
// in the root of the classpath
@ContextConfiguration({"/applicationContext.xml", "/applicationContext-test.xml"})
public class MyTest {
    // class body...
}

@ContextConfiguration supports an alias for the locations attribute through the standard value attribute. Thus, if you do not need to configure a custom ContextLoader, you can omit the declaration of the locations attribute name and declare the resource locations by using the shorthand format demonstrated in the following example. @ContextConfiguration also supports a boolean inheritLocations attribute that denotes whether resource locations from superclasses should be inherited. The default value is true, which means that an annotated class inherits the resource locations defined by an annotated superclass. Specifically, the resource locations for an annotated class are appended to the list of resource locations defined by an annotated superclass. Thus, subclasses have the option of extending the list of resource locations. In the following example, the ApplicationContext for ExtendedTest is loaded from "/base-context.xml" and "/extended-context.xml", in that order. Beans defined in "/extended-context.xml" may therefore override those defined in "/base-context.xml".

@RunWith(SpringJUnit4ClassRunner.class)
// ApplicationContext will be loaded from "/base-context.xml" in the root of the classpath
@ContextConfiguration("/base-context.xml")
public class BaseTest {
    // class body...
}

// ApplicationContext will be loaded from "/base-context.xml" and "/extended-context.xml"
// in the root of the classpath
@ContextConfiguration("/extended-context.xml")
public class ExtendedTest extends BaseTest {
    // class body...
}

If inheritLocations is set to false, the resource locations for the annotated class shadows and effectively replaces any resource locations defined by a superclass.

By default, once loaded, the configured ApplicationContext is reused for each test. Thus the setup cost is incurred only once (per test fixture), and subsequent test execution is much faster. In the unlikely case that a test dirties (modifies) the application context, requiring reloading -- for example, by changing a bean definition or the state of an application object -- you can annotate your test method with @DirtiesContext (assuming DirtiesContextTestExecutionListener has been configured, which is the default) to cause the test fixture to reload the configurations and rebuild the application context before executing the next test.

When you configure the DependencyInjectionTestExecutionListener -- which is configured by default through the @TestExecutionListeners annotation-- the dependencies of your test instances are injected from beans in the application context you configured through @ContextConfiguration by setter injection, field injection, or both, depending on which annotations you choose and whether you place them on setter methods or fields. For consistency with the annotation support introduced in Spring 2.5, you can use Spring's @Autowired annotation or the @Resource annotation from JSR 250. The semantics for both are consistent throughout the Spring Framework. For example, if you prefer autowiring by type, annotate your setter methods or fields with @Autowired. If you prefer to have your dependencies injected by name, annotate your setter methods or fields with @Resource.

	Tip
	The TestContext framework does not instrument the manner in which a test instance is instantiated. Thus the use of @Autowired for constructors has no effect for test classes.

Because @Autowired performs autowiring by type, if you have multiple bean definitions of the same type, you cannot rely on this approach for those particular beans. In that case, you can use @Resource for injection by name. Alternatively, if your test class has access to its ApplicationContext, you can perform an explicit lookup by using (for example) a call to applicationContext.getBean("titleDao"). A third option is to use @Autowired in conjunction with @Qualifier.

If you do not want dependency injection applied to your test instances, simply do not annotate fields or setter methods with @Autowired or @Resource. Alternatively, you can disable dependency injection altogether by explicitly configuring your class with @TestExecutionListeners and omitting DependencyInjectionTestExecutionListener.class from the list of listeners.

Consider the scenario of a class, HibernateTitleDao, as outlined in the Goals section. (We will look at the application context configuration after all sample code listings.) A JUnit 4-based implementation of the test class itself uses @Autowired for field injection.

Note

The dependency injection behavior in the following code listings is not in any way specific to JUnit 4. The same DI techniques can be used in conjunction with any testing framework. The following examples make calls to static assertion methods such as assertNotNull() but without prepending the call with Assert. In such cases, assume that the method was properly imported through an import static declaration that is not shown in the example.

@RunWith(SpringJUnit4ClassRunner.class)
// specifies the Spring configuration to load for this test fixture
@ContextConfiguration("daos.xml")
public final class HibernateTitleDaoTests {

    // this instance will be dependency injected by type
    @Autowired    
    private HibernateTitleDao titleDao;

    public void testLoadTitle() throws Exception {
        Title title = this.titleDao.loadTitle(new Long(10));
        assertNotNull(title);
    }
}

Alternatively, you can configure the class to use @Autowired for setter injection.

@RunWith(SpringJUnit4ClassRunner.class)
// specifies the Spring configuration to load for this test fixture
@ContextConfiguration("daos.xml")
public final class HibernateTitleDaoTests {

    // this instance will be dependency injected by type
    private HibernateTitleDao titleDao;

    @Autowired
    public void setTitleDao(HibernateTitleDao titleDao) {
        this.titleDao = titleDao;
    }

    public void testLoadTitle() throws Exception {
        Title title = this.titleDao.loadTitle(new Long(10));
        assertNotNull(title);
    }
}

Here is an example of @Resource for field injection.

@RunWith(SpringJUnit4ClassRunner.class)
// specifies the Spring configuration to load for this test fixture
@ContextConfiguration("daos.xml")
public final class HibernateTitleDaoTests {

    // this instance will be dependency injected by name
    @Resource
    private HibernateTitleDao titleDao;

    public void testLoadTitle() throws Exception {
        Title title = this.titleDao.loadTitle(new Long(10));
        assertNotNull(title);
    }
}

Here is an example of @Resource for setter injection.

@RunWith(SpringJUnit4ClassRunner.class)
// specifies the Spring configuration to load for this test fixture
@ContextConfiguration("daos.xml")
public final class HibernateTitleDaoTests {

    // this instance will be dependency injected by name
    private HibernateTitleDao titleDao;
    
    @Resource
    public void setTitleDao(HibernateTitleDao titleDao) {
        this.titleDao = titleDao;
    }

    public void testLoadTitle() throws Exception {
        Title title = this.titleDao.loadTitle(new Long(10));
        assertNotNull(title);
    }
}

The preceding code listings use the same XML context file referenced by the @ContextConfiguration annotation (that is, daos.xml), which looks like this:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="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">

    <!-- this bean will be injected into the HibernateTitleDaoTests class -->
    <bean id="titleDao" class="com.foo.dao.hibernate.HibernateTitleDao">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    
    <bean id="sessionFactory" 
				class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <!-- dependencies elided for clarity -->
    </bean>

</beans>

Note

If you are extending from a Spring-provided test base class that happens to use @Autowired on one of its setter methods, you might have multiple beans of the affected type defined in your application context: for example, multiple DataSource beans. In such a case, you can override the setter and use the @Qualifier annotation to indicate a specific target bean as follows: // ... @Autowired @Override public void setDataSource(@Qualifier("myDataSource") DataSource dataSource) { super.setDataSource(dataSource); } // ... The specified qualifier value indicates the specific DataSource bean to inject, narrowing the set of type matches to a specific bean. Its value is matched against <qualifier> declarations within the corresponding <bean> definitions. The bean name is used as a fallback qualifier value, so you may effectively also point to a specific bean by name there (as shown above, assuming that "myDataSource" is the bean id). If there is only one DataSource bean to begin with, then the qualifier does not have any effect, independent from the bean name of that single matching bean. Alternatively, consider using the @Resource annotation on such overridden setter methods, defining the target bean name explicitly, with no type matching semantics. Note that this always points to a bean with that specific name, no matter whether there is one or more beans of the given type. // ... @Resource("myDataSource") @Override public void setDataSource(DataSource dataSource) { super.setDataSource(dataSource); } // ...

In the TestContext framework, transactions are managed by the TransactionalTestExecutionListener, which is configured through the @TestExecutionListeners annotation by default, even if you do not explicitly declare @TestExecutionListeners on your test class. To enable support for transactions, however, you must provide a PlatformTransactionManager bean in the application context loaded by @ContextConfiguration semantics. In addition, you must declare @Transactional either at the class or method level.

For class-level transaction configuration (that is, setting the bean name for the transaction manager and the default rollback flag), see the @TransactionConfiguration entry in the annotation support section.

If transactions are not enabled for the entire test class, you can annotate methods explicitly with @Transactional. To control whether a transaction should commit for a particular test method, you can use the @Rollback annotation to override the class-level default rollback setting.

AbstractTransactionalJUnit38SpringContextTests, AbstractTransactionalJUnit4SpringContextTests, and AbstractTransactionalTestNGSpringContextTests are preconfigured for transactional support at the class level.

Occasionally you need to execute certain code before or after a transactional test method but outside the transactional context, for example, to verify the initial database state prior to execution of your test or to verify expected transactional commit behavior after test execution (for example, if the test was configured not to roll back the transaction). TransactionalTestExecutionListener supports the @BeforeTransaction and @AfterTransaction annotations exactly for such scenarios. Simply annotate any public void method in your test class with one of these annotations, and the TransactionalTestExecutionListener ensures that your before transaction method or after transaction method is executed at the appropriate time.

	Tip
	Any before methods (for example, methods annotated with JUnit 4's @Before) and any after methods (such as methods annotated with JUnit 4's @After) are executed within a transaction. In addition, methods annotated with @BeforeTransaction or @AfterTransaction are naturally not executed for tests annotated with @NotTransactional. However, @NotTransactional is deprecated as of Spring 3.0.

The following JUnit 4 based example displays a fictitious integration testing scenario highlighting several transaction-related annotations. Consult the annotation support section of the reference manual for further information and configuration examples.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@TransactionConfiguration(transactionManager="txMgr", defaultRollback=false)
@Transactional
public class FictitiousTransactionalTest {

    @BeforeTransaction
    public void verifyInitialDatabaseState() {
        // logic to verify the initial state before a transaction is started
    }

    @Before
    public void setUpTestDataWithinTransaction() {
        // set up test data within the transaction
    }

    @Test
    // overrides the class-level defaultRollback setting
    @Rollback(true)
    public void modifyDatabaseWithinTransaction() {
        // logic which uses the test data and modifies database state
    }

    @After
    public void tearDownWithinTransaction() {
        // execute "tear down" logic within the transaction
    }

    @AfterTransaction
    public void verifyFinalDatabaseState() {
        // logic to verify the final state after transaction has rolled back
    }

}

Avoid false positives when testing ORM code

When you test code involving an ORM framework such as JPA or Hibernate, flush the underlying session within test methods which update the state of the session. Failing to flush the ORM framework's underlying session can produce false positives: your test may pass, but the same code throws an exception in a live, production environment. In the following Hibernate-based example test case, one method demonstrates a false positive and the other method correctly exposes the results of flushing the session. // ... @Autowired private SessionFactory sessionFactory; @Test // no expected exception! public void falsePositive() { updateEntityInHibernateSession(); // False positive: an exception will be thrown once the session is // finally flushed (i.e., in production code) } @Test(expected = GenericJDBCException.class) public void updateWithSessionFlush() { updateEntityInHibernateSession(); // Manual flush is required to avoid false positive in test sessionFactory.getCurrentSession().flush(); } // ...