The document provides an overview of testing features introduced in Spring 3.1, focusing on the Spring TestContext framework, which simplifies integration testing for Spring-based applications, and new support for testing with @Configuration classes and environment profiles. It details various testing annotations, integration scenarios, and example test cases, emphasizing the importance of unit and integration testing with proper configuration. Additionally, it discusses the Spring MVC test support capabilities, allowing for comprehensive controller testing without the need for a running servlet container.

1. Spring 3.1 and MVC
Testing Support
Sam Brannen
Swiftmind
Rossen Stoyanchev
SpringSource, VMware
SpringOne 2GX
October 28, 2011

2. Sam Brannen
Senior Software Consultant @ Swiftmind
Java developer with 13+ years' experience
Spring Framework Core Developer
Lead author of Spring in a Nutshell
Previous SpringSource dm Server™ developer
Presenter on Spring, Java, OSGi, and testing

3. Rossen Stoyanchev
Staff Engineer SpringSource, VMware
Spring MVC, Spring Web Flow committer
Teach and consult, Spring Projects
Spring Web course author
NYC area

4. Goals of the
Presentation
Gain an overview of testing features
in Spring 3.1
Learn about the new Spring MVC
Test Support project

5. Agenda
Spring TestContext Framework
Testing with @Configuration Classes
Testing with Environment Profiles
Spring MVC Test Support
Q&A

6. Show of Hands...
JUnit / TestNG
Spring 2.5 / 3.0 / 3.1
Integration testing with Spring
Spring TestContext Framework
Spring MVC
Spring MVC Test Support

7. Spring TestContext
Framework

8. Introduced in Spring 2.5

9. Revised in Spring 3.1

10. Unit and integration testing

11. Annotation-driven

12. Convention over Configuration

13. JUnit & TestNG

14. Spring & Unit Testing
POJO-based programming model
Program to interfaces
IoC / Dependency Injection
Out-of-container testability
Testing mocks/stubs for various APIs: Servlet,
Portlet, JNDI
General purpose testing utilities
ReflectionTestUtils
ModelAndViewAssert

15. Spring & Integration Testing
ApplicationContext management & caching
Dependency injection of test instances
Transactional test management
with default rollback semantics
SimpleJdbcTestUtils
JUnit 3.8 support classes are deprecated as of
Spring 3.0/3.1

16. Spring Test Annotations
Application Contexts
@ContextConfiguration, @DirtiesContext
@TestExecutionListeners
Dependency Injection
@Autowired, @Qualifier, @Inject, …
Transactions
@Transactional, @TransactionConfiguration, @Rollback,
@BeforeTransaction, @AfterTransaction

17. Spring JUnit Annotations
Testing Profiles
groups, not bean definition
profiles
@IfProfileValue,
@ProfileValueSourceConfiguration
JUnit extensions
@Timed, @Repeat

18. Using the TestContext
Framework
Use the SpringJUnit4ClassRunner for
JUnit 4.5+
Instrument test class with
TestContextManager for TestNG
Extend one of the base classes
Abstract(Transactional)[JUnit4|TestNG]Spri

19. Example: @POJO Test Class
public class OrderServiceTests {
@Test
public void testOrderService() { … }
}

20. Example: @POJO Test Class
@RunWith(SpringJUnit4ClassRunner.class)
public class OrderServiceTests {
@Test
public void testOrderService() { … }
}

21. Example: @POJO Test Class
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class OrderServiceTests {
@Test
public void testOrderService() { … }
}

22. Example: @POJO Test Class
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration // defaults to
// OrderServiceTests-context.xml in same package
public class OrderServiceTests {
@Test
public void testOrderService() { … }
}

23. Example: @POJO Test Class
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration // defaults to
// OrderServiceTests-context.xml in same package
public class OrderServiceTests {
@Autowired
private OrderService orderService;
@Test
public void testOrderService() { … }
}

24. Example: @POJO Test Class
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration // defaults to
// OrderServiceTests-context.xml in same package
@Transactional
public class OrderServiceTests {
@Autowired
private OrderService orderService;
@Test
public void testOrderService() { … }
}

25. Example: @POJO Test Class
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration // defaults to
// OrderServiceTests-context.xml in same package
@Transactional
public class OrderServiceTests {
@Autowired
private OrderService orderService;
@BeforeTransaction
public void verifyInitialDatabaseState() { … }
@Test
public void testOrderService() { … }
}

26. Example: @POJO Test Class
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration // defaults to
// OrderServiceTests-context.xml in same package
@Transactional
public class OrderServiceTests {
@Autowired
private OrderService orderService;
@BeforeTransaction
public void verifyInitialDatabaseState() { … }
@Before
public void setUpTestDataWithinTransaction() { … }
@Test
public void testOrderService() { … }
}

27. Core Components

28. TestContext
Tracks context for current test
Delegates to a ContextLoader
Caches ApplicationContext

29. TestContextManager
Manages the TestContext
Signals events to listeners:
before: before-class methods
after: test instantiation
before: before methods
after: after methods
after: after-class methods

30. TestExecutionListener SPI
Reacts to test execution events
Receives reference to current TestContext
Out of the box:
DependencyInjectionTestExecutionListener
DirtiesContextTestExecutionListener
TransactionalTestExecutionListener

31. TestExecutionListener

32. TEL: Prepare Instance

33. TEL: Befores and Afters

34. ContextLoader SPI
Strategy for loading application contexts
from resource locations
Out of the box:
GenericXmlContextLoader
GenericPropertiesContextLoader

35. ContextLoader 2.5

36. Putting it all together

37. New in Spring 3.1

38. Support for ...

39. testing with @Configuration classes

40. and

41. testing with environment profiles

42. made possible by ...

43. SmartContextLoader

44. AnnotationConfigContextLoader

45. DelegatingSmartContextLoader

46. updated context cache key generation

47. SmartContextLoader SPI
Supersedes ContextLoader
Strategy for loading application
contexts
From @Configuration classes or
resource locations
Supports environment profiles

48. Implementations
GenericXmlContextLoader
GenericPropertiesContextLoader
AnnotationConfigContextLoader
DelegatingSmartContextLoader

49. ContextLoader 2.5

50. ContextLoader 3.1

51. Testing with
@Configuration Classes

52. @ContextConfiguration
accepts a new classes attribute...

53. @ContextConfiguration(
classes={DataAccessConfig.class,
ServiceConfig.class})

54. First, a review with XML config for
comparison...

55. OrderServiceTest-context.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans ...>
<!-- will be injected into OrderServiceTest -->
<bean id="orderService"
class="com.example.OrderServiceImpl">
<!-- set properties, etc. -->
</bean>
<!-- other beans -->
</beans>

56. OrderServiceTest.java
package com.example;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class OrderServiceTest {
@Autowired
private OrderService orderService;
@Test
public void testOrderService() {
// test the orderService
}
}

57. Let's rework that example to use a
@Configuration class and the new
AnnotationConfigContextLoader...

58. OrderServiceTest.java
@RunWith(SpringJUnit4ClassRunner.class)
public class OrderServiceTest {
@Autowired
private OrderService orderService;
// @Test methods ...
}

59. OrderServiceTest.java
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(
loader=AnnotationConfigContextLoader.class)
public class OrderServiceTest {
@Autowired
private OrderService orderService;
// @Test methods ...
}

60. OrderServiceTest.java
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class OrderServiceTest {
@Autowired
private OrderService orderService;
// @Test methods ...
}

61. OrderServiceTest.java
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class OrderServiceTest {
@Configuration
static class Config {
}
@Autowired
private OrderService orderService;
// @Test methods ...
}

62. OrderServiceTest.java
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class OrderServiceTest {
@Configuration
static class Config {
@Bean // will be injected into OrderServiceTest
public OrderService orderService() {
OrderService orderService = new OrderServiceImpl();
// set properties, etc.
return orderService;
}
}
@Autowired
private OrderService orderService;
// @Test methods ...
}

63. What's changed?
No XML
Bean definitions are converted to
Java
using @Configuration and @Bean
Otherwise, the test remains
unchanged

64. But what if we don't want a static
inner @Configuration class?

65. Just externalize the config...

66. OrderServiceConfig.java
@Configuration
public class OrderServiceConfig {
@Bean // will be injected into OrderServiceTest
public OrderService orderService() {
OrderService orderService = new OrderServiceImpl();
// set properties, etc.
return orderService;
}
}

67. And reference the config classes in
@ContextConfiguration...

68. OrderServiceConfig.java
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=OrderServiceConfig.class)
public class OrderServiceTest {
@Autowired
private OrderService orderService;
@Test
public void testOrderService() {
// test the orderService
}
}

69. @Configuration + XML
Q: How can we combine
@Configuration classes with XML
config?
A: Choose one as the entry point.
That's how it works in production
anyway

70. Importing Configuration
In XML:
include @Configuration classes via
component scanning
or define them as normal Spring
beans
In an @Configuration class:
use @ImportResource to import XML
config files

71. Testing with
Environment Profiles

72. @ActiveProfiles
To activate bean definition profiles in tests...
Annotate a test class with
@ActiveProfiles
Supply a list of profiles to be
activated for the test
Can be used with @Configuration
classes and XML config

73. Let's look at an example with XML
config...

74. app-config.xml (1/2)
<beans ... >
<bean id="transferService"
class="com.example.DefaultTransferService">
<constructor-arg ref="accountRepository"/>
<constructor-arg ref="feePolicy"/>
</bean>
<bean id="accountRepository"
class="com.example.JdbcAccountRepository">
<constructor-arg ref="dataSource"/>
</bean>
<bean id="feePolicy"
class="com.example.ZeroFeePolicy"/>
<!-- dataSource -->
</beans>

75. app-config.xml (2/2)
<beans ... >
<!-- transferService, accountRepository, feePolicy -->
</beans>

76. app-config.xml (2/2)
<beans ... >
<!-- transferService, accountRepository, feePolicy -->
<beans profile="production">
<jee:jndi-lookup id="dataSource"
jndi-name="java:comp/env/jdbc/datasource"/>
</beans>
</beans>

77. app-config.xml (2/2)
<beans ... >
<!-- transferService, accountRepository, feePolicy -->
<beans profile="production">
<jee:jndi-lookup id="dataSource"
jndi-name="java:comp/env/jdbc/datasource"/>
</beans>
<beans profile="dev">
<jdbc:embedded-database id="dataSource">
<jdbc:script
location="classpath:schema.sql"/>
<jdbc:script
location="classpath:test-data.sql"/>
</jdbc:embedded-database>
</beans>
</beans>

78. TransferServiceTest.java
@RunWith(SpringJUnit4ClassRunner.class)
public class TransferServiceTest {
@Autowired
private TransferService transferService;
@Test
public void testTransferService() {
// test the transferService
}
}

79. TransferServiceTest.java
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/app-config.xml")
public class TransferServiceTest {
@Autowired
private TransferService transferService;
@Test
public void testTransferService() {
// test the transferService
}
}

80. TransferServiceTest.java
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/app-config.xml")
@ActiveProfiles("dev")
public class TransferServiceTest {
@Autowired
private TransferService transferService;
@Test
public void testTransferService() {
// test the transferService
}
}

81. And now an example with
@Configuration classes

82. TransferServiceConfig.java
@Configuration
public class TransferServiceConfig {
@Autowired DataSource dataSource;
@Bean
public TransferService transferService() {
return new DefaultTransferService(accountRepository(),
feePolicy());
}
@Bean
public AccountRepository accountRepository() {
return new JdbcAccountRepository(dataSource);
}
@Bean
public FeePolicy feePolicy() {
return new ZeroFeePolicy();
}
}

83. }
JndiDataConfig.java
@Configuration
@Profile("production")
public class JndiDataConfig {
@Bean
public DataSource dataSource() throws Exception {
Context ctx = new InitialContext();
return (DataSource)
ctx.lookup("java:comp/env/jdbc/datasource");
}
}

84. StandaloneDataConfig.java
@Configuration
@Profile("dev")
public class StandaloneDataConfig {
@Bean
public DataSource dataSource() {
return new EmbeddedDatabaseBuilder()
.setType(EmbeddedDatabaseType.HSQL)
.addScript("classpath:schema.sql")
.addScript("classpath:test-data.sql")
.build();
}
}

85. And finally the test class...

86. TransferServiceTest.java
package com.bank.service;
@RunWith(SpringJUnit4ClassRunner.class)
public class TransferServiceTest {
@Autowired
private TransferService transferService;
@Test
public void testTransferService() {
// test the transferService
}
}

87. TransferServiceTest.java
package com.bank.service;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(
classes={
TransferServiceConfig.class,
StandaloneDataConfig.class,
JndiDataConfig.class})
public class TransferServiceTest {
@Autowired
private TransferService transferService;
@Test
public void testTransferService() {
// test the transferService
}
}

88. TransferServiceTest.java
package com.bank.service;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(
classes={
TransferServiceConfig.class,
StandaloneDataConfig.class,
JndiDataConfig.class})
@ActiveProfiles("dev")
public class TransferServiceTest {
@Autowired
private TransferService transferService;
@Test
public void testTransferService() {
// test the transferService
}
}

89. Active Profile Inheritance
@ActiveProfiles supports inheritance as well
Via the inheritProfiles attribute
See Javadoc for an example

90. ApplicationContext
Caching

91. Until Spring 3.1

92. application contexts were cached

93. but using only resource locations for
the key.

94. Now there are different
requirements...

95. New Key Generation Algorithm
The context cache key generation algorithm has been updated to include...
locations (from @ContextConfiguration)
classes (from @ContextConfiguration)
contextLoader (from @ContextConfiguration)
activeProfiles (from @ActiveProfiles)

96. Summary
The Spring TestContext Framework simplifies
integration testing of Spring-based
applications
Spring 3.1 provides first-class testing support
for:
@Configuration classes
Environment profiles
See the Testing with @Configuration Classes
and Profiles blog for further insight

97. Spring MVC Test
Support

98. How Do You Test an
@Controller?

99. @Controller
@RequestMapping("/accounts")
public class AccountController {
// ...
@ModelAttribute
public Account getAccount(String number) {
return this.accountManager.getAccount(number);
}
@RequestMapping(method = RequestMethod.POST)
public String save(@Valid Account account,
BindingResult result) {
if (result.hasErrors()) {
return "accounts/edit";
}
this.accountManager.saveOrUpdate(account);
return "redirect:accounts";
}
}

100. Unit Test?
Create controller instance
Mock or stub services & repositories

101. Example
@Test
public void testSave() {
Account account = new Account();
BindingResult result =
new BeanPropertyBindingResult(account, "account");
}

102. Example
@Test
public void testSave() {
Account account = new Account();
BindingResult result =
new BeanPropertyBindingResult(account, "account");
AccountManager mgr = createMock(AccountManager.class);
mgr.saveOrUpdate(account);
replay(mgr);
}

103. Example
@Test
public void testSave() {
Account account = new Account();
BindingResult result =
new BeanPropertyBindingResult(account, "account");
AccountManager mgr = createMock(AccountManager.class);
mgr.saveOrUpdate(account);
replay(mgr);
AccountController contrlr = new AccountController(mgr);
String view = contrlr.save(account, result);
}

104. Example
@Test
public void testSave() {
Account account = new Account();
BindingResult result =
new BeanPropertyBindingResult(account, "account");
AccountManager mgr = createMock(AccountManager.class);
mgr.saveOrUpdate(account);
replay(mgr);
AccountController contrlr = new AccountController(mgr);
String view = contrlr.save(account, result);
assertEquals("redirect:accounts", view);
verify(mgr);
}

105. Example With Failure
@Test
public void testSave() {
Account account = new Account();
BindingResult result =
new BeanPropertyBindingResult(account, "account");
result.reject("error.code", "default message")
}

106. Example With Failure
@Test
public void testSave() {
Account account = new Account();
BindingResult result =
new BeanPropertyBindingResult(account, "account");
result.reject("error.code", "default message")
AccountManager mgr = createMock(AccountManager.class);
replay(mgr);
}

107. Example With Failure
@Test
public void testSave() {
Account account = new Account();
BindingResult result =
new BeanPropertyBindingResult(account, "account");
result.reject("error.code", "default message")
AccountManager mgr = createMock(AccountManager.class);
replay(mgr);
AccountController contrlr = new AccountController(mgr);
String view = contrlr.save(account, result);
assertEquals("accounts/edit", view);
verify(mgr);
}

108. Not Fully Tested
Request mappings
Binding errors
Type conversion
Etc.

109. Integration Test?
Selenium
JWebUnit
etc.

110. It Requires...
A running servlet container
More time to execute
More effort to maintain
Server is a black box

111. Actually...

112. it's an end-to-end test

113. the only way to verify...
Client-side behavior
Interaction with other server instances
Redis, Rabbit, etc.

114. We'd also like to...
Test controllers once!
Fully & quickly
Execute tests often

115. In summary...
We can't replace the need for end-to-
end tests
But we can minimize errors
Have confidence in @MVC code
During end-to-end tests

116. Spring MVC Test
Built on spring-test
No Servlet container
Drives Spring MVC infrastructure
Both server & client-side test support
(i.e. RestTemplate code)
Inspired by spring-ws-test

117. The Approach
Re-use controller test fixtures
I.e. mocked services & repositories
Invoke @Controller classes through
@MVC infrastructure

118. Example
String contextLoc = "classpath:appContext.xml";
String warDir = "src/main/webapp";
MockMvc mockMvc =
xmlConfigSetup(contextLoc)
.configureWebAppRootDir(warDir, false)
.build();
mockMvc.perform(post("/persons"))
.andExpect(response().status().isOk())
.andExpect(response().forwardedUrl("/add.jsp"))
.andExpect(model().size(1))
.andExpect(model().hasAttributes("person"));

119. Under the Covers
Mock request/response from spring-test
DispatcherServlet replacement
Multiple ways to initialize MVC
infrastructure
Save results for expectations

120. Ways To Initialize MVC
Infrastructure

121. From Existing XML Config
// XML config
MockMvc mockMvc =
xmlConfigSetup("classpath:appContext.xml")
.activateProfiles(..)
.configureWebAppRootDir(warDir, false)
.build();

122. From Existing Java Config
// Java config
MockMvc mockMvc =
annotationConfigSetup(WebConfig.class)
.activateProfiles(..)
.configureWebAppRootDir(warDir, false)
.build();

123. Manually
MockMvc mockMvc =
standaloneSetup(new PersonController())
.setMessageConverters(..)
.setValidator(..)
.setConversionService(..)
.addInterceptors(..)
.setViewResolvers(..)
.setLocaleResolver(..)
.build();

124. About Manual Setup
MVC components instantiated directly
Not looked up in Spring context
Focused, readable tests
But must verify MVC config separately

125. TestContext Framework Example
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(
locations={"/org/example/servlet-context.xml"})
public class TestContextTests {
@Autowired
private WebApplicationContext wac;
@Before
public void setup() {
MockMvc mockMvc =
MockMvcBuilders.webApplicationContextSetup(this.wac)
.build();
}
}

126. TestContext Framework
Caches loaded Spring configuration
Potentially across all tests!

127. However...
WebApplicationContext not supported yet
To be supported in Spring 3.2

128. In the mean time...
You can use a custom ContextLoader
Example exists in spring-test-mvc

129. Step 1
Add static imports
MockMvcBuilders.*
MockMvcRequestBuilders.*
MockMvcResultActions.*

130. Easy to remember...
MockMvc*

131. Also in Eclipse...
Add MockMvc* classes in Preferences
Java -> Editor -> Favorites
Helps content assist

132. Step 2
Initialize MVC infrastructure
String contextLoc = "classpath:appContext.xml";
String warDir = "src/main/webapp";
MockMvc mockMvc = xmlConfigSetup("classpath:appContext.xml")
.configureWebAppRootDir(warDir, false)
.build()
// ...

133. Step 3
Build Request
String contextLoc = "classpath:appContext.xml";
String warDir = "src/main/webapp";
MockMvc mockMvc = xmlConfigSetup("classpath:appContext.xml")
.configureWebAppRootDir(warDir, false)
.build()
mockMvc.perform(get("/").accept(MediaType.APPLICATION_XML))
// ...

134. Step 4
Add Expectations
String contextLoc = "classpath:appContext.xml";
String warDir = "src/main/webapp";
MockMvc mockMvc = xmlConfigSetup("classpath:appContext.xml")
.configureWebAppRootDir(warDir, false)
.build()
mockMvc.perform(get("/").accept(MediaType.APPLICATION_XML))
.andExpect(response().status().isOk())
.andExpect(response().contentType(MediaType))
.andExpect(response().content().xpath(String).exists())
.andExpect(response().redirectedUrl(String))
.andExpect(model().hasAttributes(String...));
// ...

135. Step 5
Debug
String contextLoc = "classpath:appContext.xml";
String warDir = "src/main/webapp";
MockMvc mockMvc = xmlConfigSetup("classpath:appContext.xml")
.configureWebAppRootDir(warDir, false)
.build()
mockMvc.perform(get("/").accept(MediaType.APPLICATION_XML))
.andPrint(toConsole());
// ...

136. Demo
https://github.com/SpringSource/spring-test-mvc
Sample Tests:
org.springframework.test.web.server.samples

137. Client-Side Example
RestTemplate restTemplate = ... ;
MockRestServiceServer.createServer(restTemplate)
.expect(requestTo(String))
.andExpect(method(HttpMethod))
.andExpect(body(String))
.andExpect(headerContains(String, String))
.andRespond(withResponse(String, HttpHeaders));

138. Project Availability
github.com/SpringSource/spring-test-mvc
Request for feedback!
Send comments
Pull requests

139. Nightly Snapshot Available
<repository>
<id>org.springframework.maven.snapshot</id>
<name>Spring Maven Snapshot Repository</name>
<url>http://maven.springframework.org/snapshot</url>
<releases>
<enabled>false</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>

140. In Closing ...

141. This Presentation
Source:
https://github.com/rstoyanchev/spring-31-and-mvc-
testing-support
Slides:
http://rstoyanchev.github.com/spring-31-and-mvc-
test

142. Resources for Spring MVC Test
Project Home:
https://github.com/SpringSource/spring-test-mvc
Sample Tests:
org.springframework.test.web.server.samples

143. Resources for Core Spring
Spring Framework:
http://www.springsource.org/spring-core
Reference Manual: Spring 3.1 RC1
Forums: http://forum.springframework.org
JIRA: https://jira.springsource.org
Spring in a Nutshell … available in 2012

144. Q&A
Sam Brannen
Web: Swiftmind.com
Twitter: @sam_brannen
Rossen Stoyanchev
Web: SpringSource.com
Twitter: @rstoya05