Testing with Spring 4.x

© 2012-2014 Sam Brannen and licensed under a Creative Commons Attribution-NonCommercial license
Unless otherwise indicated, these slides are © 2012-2014 Sam Brannen and licensed under a
Creative Commons Attribution-NonCommercial license: http://creativecommons.org/licenses/by-nc/3.0/
Testing with Spring 4.x
Sam Brannen
@sam_brannen

Sam Brannen
•  Spring and Java Consultant @ Swiftmind
•  Java Developer for over 15 years
•  Spring Framework Core Committer since 2007
•  Component lead for spring-test
•  Spring Trainer
•  Speaker on Spring, Java, and testing
•  Swiss Spring User Group Lead
2

Areas of expertise
–  Spring *
–  Java EE
–  Software Architecture
–  Software Engineering Best
Practices
Where you find us
•  Zurich, Switzerland
•  @swiftmind
•  http://www.swiftmind.com
3
Your experts for Spring and Enterprise Java

A show of hands…
4
?
?
?
?
?

Agenda
•  Deprecations, Pruning, & Dependencies
•  Recap of Testing with Spring 3.x
•  Testing Themes in 4.x
•  Details, Tips, & Examples
•  Q&A
5

Deprecations, Pruning, & Dependencies
6

Spring Cleaning in 4.x
•  All deprecated packages removed
•  Many deprecated methods and fields removed as well
•  Mind the deprecation warnings… before upgrading from 3.x
7

Pruning in 4.0
•  JUnit 3.8 support
•  Use JUnit 4 or TestNG
•  @ExpectedException
•  Use @Test(expected) or @Rule ExpectedException in JUnit
•  Use @Test(expectedExceptions) in TestNG
•  @NotTransactional
•  Use @Transactional(propagation=NOT_SUPPORTED)
•  SimpleJdbcTestUtils
•  Use JdbcTestUtils, ScriptUtils, or @Sql
8

Dependency Upgrades in 4.0
•  Servlet API mocks
•  Now based on Servlet 3.0
•  Servlet 2.5 still supported in production
•  JUnit
•  Tested against à 4.11
•  TestNG
•  Tested against à 6.8.5
9

Dependency Upgrades in 4.1
•  JUnit
•  Minimum version à 4.9
•  Recommended à 4.11
•  TestNG
•  Tested against à 6.8.8
10

Testing with Spring 3.x
11

Testing Themes from Spring 3.x (1/2)
•  Embedded databases
•  <jdbc:embedded-database /> & <jdbc:initialize-database />
•  EmbeddedDatabaseBuilder & EmbeddedDatabaseFactoryBean
•  @Configuration classes
•  @ActiveProfiles
•  ApplicationContextInitializers
12

Testing Themes from Spring 3.x (2/2)
•  @WebAppConfiguration
•  Loading WebApplicationContexts
•  Testing request- and session-scoped beans
•  @ContextHierarchy
•  Web, Batch, etc.
•  Spring MVC Test framework
•  Server-side MVC and REST tests
•  Client-side REST tests
13

Ex: Web Integration Test (1/2)
14
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextHierarchy({
@ContextConfiguration(classes = RootConfig.class),
@ContextConfiguration(classes = WebConfig.class)
})
@ActiveProfiles("dev")
public class ControllerIntegrationTests {
@Autowired
private WebApplicationContext wac;
private MockMvc mockMvc;
// ...

Ex: Web Integration Test (2/2)
15
@Before
public void setup() {
this.mockMvc = MockMvcBuilders
.webAppContextSetup(this.wac).build();
}

@Test
public void person() throws Exception {
this.mockMvc.perform(get("/person/42")
.accept(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(content().string("{"name":"Sam"}"));
}

Testing Themes in Spring 4.0
16

New in 4.0 (1/3)
•  SocketUtils
•  Scan for available UDP & TCP ports
•  ActiveProfilesResolver API
•  Programmatic alternative to static profile strings
•  Set via new resolver attribute in @ActiveProfiles
•  Meta-annotation support for tests
•  Attribute overrides (optional and required)
17

New in 4.0 (2/3)
•  New deleteFromTableWhere() method in
AbstractTransactional*SpringContextTests
•  * à JUnit4 or TestNG
•  New verify() and reset() methods in
AnnotationDrivenStaticEntityMockingControl
•  Multi-line SQL comments:
•  ResourceDatabasePopulator, JdbcTestUtils, ScriptUtils
18

New in 4.0 (3/3)
•  TestContext converted to an interface
•  Allows TestContext to be mocked in unit tests
•  Simultaneous use of classes and locations in
@ContextConfiguration for hybrid loaders
•  See Spring Boot
•  Servlet API mock improvements
19

Testing Themes in Spring 4.1
20

New in 4.1 – Context Config
•  Context config with Groovy scripts
•  Declarative configuration for test property sources
•  @TestPropertySource
21

New in 4.1 – Transactions and SQL
•  Programmatic test transaction management
•  TestTransaction API
•  Declarative SQL script execution
•  @Sql, @SqlConfig, @SqlGroup
•  Improved docs for transactional tests
22

New in 4.1 – Bootstrap & TestExecutionListeners
•  TestContext bootstrap strategy
•  TestContextBootstrapper & @BootstrapWith
•  Automatic discovery of default TestExecutionListeners
•  Uses SpringFactoriesLoader
•  Already used by Spring Security
•  Merging custom TestExecutionListeners with defaults
•  @TestExecutionListeners(mergeMode=MERGE_WITH_DEFAULTS)
•  Defaults to REPLACE_DEFAULTS
23

New in 4.1 – Spring MVC Test
•  Assert JSON responses with JSON Assert
•  Complements JSONPath support
•  Create MockMvcBuilder recipes with MockMvcConfigurer
•  Developed to apply Spring Security setup but can be used by anyone
•  AsyncRestTemplate support in MockRestServiceServer
•  For asynchronous client-side testing
24

New in 4.1 – Odds & Ends
•  AssertThrows: refactored to support Throwable
•  Various improvements to Servlet API mocks
25

Details, Tips, & Examples
26

SocketUtils
•  Utility class introduced in Spring Framework 4.0
•  Located in spring-core
•  Can be used in production code
•  But ideal for embedded testing scenarios (SMTP, FTP, etc.)
•  Finds available TCP and UDP ports on localhost
•  Default port range: 1024 à 65535
•  See Javadoc for all options
•  Straightforward usage in Java and @Configuration classes
27

Using SocketUtils in XML Config
•  Via fully qualified class name and SpEL

<bean id="bean1" ... p:port=
"#{T(org.springframework.util.SocketUtils).findAvailableTcpPort(12000)}" />
•  Via socketUtils bean and SpEL (as of Spring 4.0.8 & 4.1.1)
<bean id="socketUtils"
class="org.springframework.util.SocketUtils" />
<bean id="bean1" ...
p:port="#{socketUtils.findAvailableTcpPort(12000)}" />
<bean id="bean2" ...
p:port="#{socketUtils.findAvailableTcpPort(30000)}" />
28

Tip: Define Free Port as Bean
•  Define the free port as a Spring Bean…

<bean id="serverPort" class="java.lang.Integer"
c:_="#{T(socketUtils.findAvailableTcpPort()}" />

•  Then reference the serverPort from other beans
•  Or inject it into components, @Configuration classes, and tests
29

Ex: @ActiveProfiles – Declarative
30
@ContextConfiguration
public class IntegrationTests {
// ...
}
But what if static
isn’t good enough?

Ex: @ActiveProfiles – Programmatic
31
public class MyResolver implements ActiveProfilesResolver {
public String[] resolve(Class<?> testClass) {
// resolve bean definition profiles for test class
}
}

@ActiveProfiles(resolver = MyProfileResolver.class)
public class IntegrationTests {
// ...
}
Implement custom resolver
And declare it

Composable Stereotypes – Quick Review
•  Combining meta-annotations on a custom stereotype
•  Automatically detected: no configuration necessary!
32

Duplicate Test Configuration == Bad
@ContextConfiguration("/test-config.xml")
@Transactional
public class OrderRepositoryTests {
}

@Transactional
public class UserRepositoryTests {
}
33
duplication
duplication

Custom Test Annotation == Good
@Target(TYPE)
@Retention(RUNTIME)
@Transactional
public @interface TransactionalDevTest { }

@TransactionalDevTest
public class OrderRepositoryTests { }

@TransactionalDevTest
public class UserRepositoryTests { }

34
common config

Composable Annotations with Overrides
•  Composable annotations may override attributes of meta-
annotations
•  Purely convention-based
•  Matched by attribute name and type
•  Can lead to potential naming conflicts
•  Cannot override the value attribute
35

Optional Annotation Attribute Override
@Target(TYPE)
@Retention(RUNTIME)
@Transactional
public @interface TransactionalTest {
String[] locations() default "/test-config.xml";
}

@TransactionalTest(locations = "/order-test-config.xml")
36
optional: overrides default
default
locations declared
here will be ignored

Required Annotation Attribute Override
@Target(TYPE)
@Retention(RUNTIME)
@Transactional
public @interface TransactionalTest {
String[] locations();
}

@TransactionalTest(locations = "/order-test-config.xml")
37
required
no default
locations declared
here will be ignored

Groovy Beans in Spring
•  Spring Framework 4.0 introduced support for the Groovy Bean
Definition DSL via the GroovyBeanDefinitionReader and
GenericGroovyApplicationContext
•  Spring Framework 4.1 introduces support for Groovy scripts in
web applications via the GroovyWebApplicationContext
•  Testing support added in 4.1…
38

Spring Bean Definitions with Groovy DSL
import org.mypackage.domain.Person;
beans {
xmlns util: 'http://www.springframework.org/schema/util'
person1(Person) {
name = "homer"
age = 45
props = [overweight: true, height: "1.8m"]
children = ["bart", "lisa"]
}
util.list(id: 'foo') {
value 'one'
value 'two'
}
}
39

Groovy Scripts for Context Config in Tests
•  Spring Framework 4.1 introduces support for Groovy scripts in
integration tests via @ContextConfiguration
•  Scripts are configured via the locations or value attribute
o  Resource semantics identical to XML
o  Default detected with “Context.groovy” suffix in same package
•  The inheritLocations flag is fully supported
•  Groovy and XML configuration can be declared together
•  Groovy WebApplicationContexts supported via
@WebAppConfiguration
40

Ex: Groovy Script Config
@ContextConfiguration("/context.groovy")
public class GroovyPersonTests {

@Autowired
private Person person;

/* test methods using person bean */
}
41

Ex: Default Groovy Script Detection
public com.example;

// ApplicationContext will be loaded from
// “classpath:com/example/MyTestContext.groovy”
public class MyTest {
/* ... */
}
42

Ex: Groovy & XML Config Together
// ApplicationContext will be loaded from
// “/context.groovy” and “/context.xml”
@ContextConfiguration({ "/context.groovy", "/context.xml" })
public class MyTest {
/* ... */
}
43

Test Property Sources
•  Spring 3.1 introduced PropertySources abstraction
•  Configured via Environment or via @PropertySource
•  Spring 4.1 supports declarative test property sources
•  Configured via @TestPropertySource
•  Test property sources are declared via annotation attributes
•  locations or value: resource locations
•  properties: inlined properties
•  both are inherited by default
44

@TestPropertySource – locations
•  String array of resource locations for Java Properties files
•  Both traditional *.properties and XML formats are supported
•  Resource semantics are identical to those for locations in
45

Ex: @TestPropertySource – locations
@TestPropertySource("/test.properties")
public class MyIntegrationTests {
// class body...
}
46

@TestPropertySource – properties
•  Inlined properties can be declared as key/value pairs
•  Uses syntax for entries in Java properties files:
•  "key=value"
•  "key:value"
•  "key value"
47

Ex: @TestPropertySource – properties
@TestPropertySource(
properties = {"foo=bar", "port: 4242"}
)
// class body...
}
48

Default Properties File Detection
•  If neither locations nor properties are defined, a default properties
file will be detected
•  Default is detected with “.properties” suffix in same package
•  If the class is com.example.MyTest, the default properties file is
“classpath:com/example/MyTest.properties”
•  Exception is thrown if default is not present
49

@TestPropertySource – Precedence
50
Inlined
Files
Application & System
test
precedence

Ex: @TestPropertySource – locations & properties
@TestPropertySource(
locations = "/test.properties",
properties = "port: 4242"
)
// class body...
}
51

Programmatic Transaction Management in Tests
•  History Lesson: Spring’s JUnit 3.8 testing framework supported
endTransaction() and startNewTransaction() methods in
AbstractTransactionalSpringContextTests
•  But… the Spring TestContext Framework, introduced in Spring
2.5, did not… until now
•  Due to popular demand, Spring 4.1 introduces a new
TestTransaction API
52

Transactions in Spring
•  Spring-managed transactions: managed by Spring in the
ApplicationContext
•  @Transactional and AOP
•  Application-managed transactions: managed programmatically within
application code
•  TransactionTemplate and TransactionSynchronizationManager
•  Test-managed transactions: managed by the Spring TestContext
Framework
•  @Transactional on test classes and test methods
•  Transaction is rolled back by default!
53

Ex: Declarative Transaction Management in Tests
@Transactional
public class TransactionalTests {

@Test
public void withinTransaction() {
/* ... */
}
54
What if we want to
stop & start the
transaction within the
test method?

TestTransaction API
•  Static methods for interacting with test-managed transactions
•  isActive()
•  isFlaggedForRollback()
•  flagForCommit()
•  flagForRollback()
•  end()
•  start()
55
query status
change default rollback setting
end: roll back or commit based on flag
start: new tx with default rollback setting

Ex: Programmatic Transaction Management in Tests
@Test
public void withinTransaction() {
// assert initial state in test database:
assertNumUsers(2);

deleteFromTables("user");

// changes to the database will be committed
TestTransaction.flagForCommit();
TestTransaction.end();
assertFalse(TestTransaction.isActive());
assertNumUsers(0);

TestTransaction.start();
// perform other actions against the database that will
// be automatically rolled back after the test completes...
}
56

Executing SQL Scripts
57

Ex: Embedded Database in Java Config
58
@Bean
public DataSource dataSource() {
return new EmbeddedDatabaseBuilder()
.setType(H2)
.setScriptEncoding("UTF-8")
.ignoreFailedDrops(true)
.addScript("schema.sql")
.addScripts("user_data.sql", "country_data.sql")
.build();
}
API greatly improved
in Spring 4.0.3

Ex: Embedded Database in XML Config
<jdbc:embedded-database id="dataSource" type="H2">
<jdbc:script location="classpath:/schema.sql" />
<jdbc:script location="classpath:/user_data.sql" />
</jdbc:embedded-database>

59

Ex: Populate Database in XML Config
<jdbc:initialize-database data-source="dataSource">
<jdbc:script location="classpath:/schema_01.sql" />
<jdbc:script location="classpath:/schema_02.sql" />
<jdbc:script location="classpath:/data_01.sql" />
<jdbc:script location="classpath:/data_02.sql" />
</jdbc:initialize-database>
60

Executing SQL per Test Method
•  The previous techniques are very useful for setting up the initial
database state
•  Q: But how can we execute SQL scripts per test method?
•  A: Programmatically via ScriptUtils,
ResourceDatabasePopulator, or abstract transactional base test
classes for JUnit and TestNG.
•  Q: OK, but how can we do that declaratively?
•  A: Via @Sql in Spring Framework 4.1!
61

Executing SQL Scripts Declaratively with @Sql
•  @Sql: declared on a test class or test method
•  method-level overrides class-level
•  The scripts attribute is used to declare resource locations for
SQL scripts
•  semantics analogous to locations in @ContextConfiguration
•  Scripts can be executed before or after a test method
•  configured via the executionPhase attribute of @Sql
62

Ex: @Sql in Action
@Sql({ "schema1.sql", "data1.sql" })
public class SqlScriptsTests {

@Test
public void classLevelScripts() { /* ... */ }

@Test
@Sql({ "schema2.sql", "data2.sql" })
public void methodLevelScripts() { /* ... */ }

63

Default SQL Script Detection
•  If no scripts are declared, a default script will be detected
•  Depending on where @Sql is declared
•  Class-level: for com.example.DbTest, the default is “classpath:com/
example/DbTest.sql”
•  Method-level: for com.example.DbTest.test(), the default is
“classpath:com/example/DbTest.test.sql”
•  If the default is not present, an exception is thrown
64

Declaring Multiple @Sql Sets
•  Declare multiple sets of @Sql scripts for varying configuration
•  Java 8: use @Sql as a repeatable annotation
•  Java 6 & 7: wrap @Sql sets in @SqlGroup
65

@Sql as a Repeatable Annotation (Java 8)
66
@Test
@Sql(
scripts="/test-schema.sql",
config = @SqlConfig(commentPrefix = "`")
@Sql("/user-data.sql")
public void userTest() {
// code that uses the test schema and test data
}
Schema uses
custom syntax

@Sql wrapped in @SqlGroup (Java 6 & 7)
67
@Test
@SqlGroup({
@Sql(
scripts="/test-schema.sql",
config = @SqlConfig(commentPrefix = "`"),
@Sql("/user-data.sql")
})
public void userTest() {
// code that uses the test schema and test data
}

Configuring SQL Scripts with @SqlConfig
•  @SqlConfig: configures script parsing and error handling
•  Class-level: serves as global configuration for the test class
•  @Sql(config): serves as local configuration for the enclosing @Sql
•  Local configuration inherits global configuration and can
selectively override global configuration
•  Transaction management for script execution is configured via
the dataSource, transactionManager, and transactionMode
attributes
•  See Javadoc and reference manual for details
68

In closing…
69

Related Sessions @ SpringOne 2GX 2014
70
•  The Quest for the Holy Integration Test
•  Ken Krueger and Rob Winch
•  September 10, 2014
•  4:30 PM - 6:00 PM
•  Building highly modular and testable business systems with
Spring Integration
•  Marius Bogoevici
•  September 11, 2014
•  10:30 AM - 12:00 PM

Spring Resources
Spring Framework: http://projects.spring.io/spring-framework
Spring Guides: http://spring.io/guides
Spring JIRA: https://jira.spring.io
Spring on GitHub: https://github.com/spring-projects/spring-framework
Stack Overflow: spring, spring-test, spring-mvc, …
71

Blogs
Spring Blog: http://spring.io/blog
Swiftmind Blog: http://www.swiftmind.com/blog
72

Q & A
Sam Brannen
@sam_brannen
www.slideshare.net/sbrannen
www.swiftmind.com
73
@springcentral | spring.io/video

Testing with Spring 4.x

More Related Content

What's hot

Similar to Testing with Spring 4.x

More from Sam Brannen

Recently uploaded

Testing with Spring 4.x