ConfigDataApplicationContextInitializer
ConfigDataApplicationContextInitializer is an ApplicationContextInitializer that can be
applied to tests to load application.properties files for Spring Boot. You can use it if you do not
need the full set of functions provided by the @SpringBootTest annotation, as shown in the following
example:
@ContextConfiguration(classes = Config.class, initializers = ConfigDataApplicationContextInitializer.class)
class MyConfigFileTests {
// ...
}
@ContextConfiguration(classes = [Config::class], initializers = [ConfigDataApplicationContextInitializer::class])
class MyConfigFileTests {
// ...
}
ConfigDataApplicationContextInitializer class
will not provide support for embedding the @Value("${...}") annotation . Its only job is to ensure
that the application.properties files are loaded into the Environment for Spring. To
support the @Value annotation, you must either additionally configure the PropertySourcesPlaceholderConfigurer,
or use the @SpringBootTest annotation, which will automatically configure it for you.
TestPropertyValues
The Class TestPropertyValues allows you to quickly add properties to a
ConfigurableEnvironment or ConfigurableApplicationContext. You can call it using the lines
key=value, as shown below:
class MyEnvironmentTests {
@Test
void testPropertySources() {
MockEnvironment environment = new MockEnvironment();
TestPropertyValues.of("org=Spring", "name=Boot").applyTo(environment);
assertThat(environment.getProperty("name")).isEqualTo("Boot");
}
}
class MyEnvironmentTests {
@Test
fun testPropertySources() {
val environment = MockEnvironment()
TestPropertyValues.of("org=Spring", "name=Boot").applyTo(environment)
assertThat(environment.getProperty("name")).isEqualTo("Boot")
}
}
OutputCapture
OutputCapture is an Extension for JUnit that can be used to capture the output of System.out
and System.err. To use, add the @ExtendWith(OutputCaptureExtension.class) annotation and
inject CapturedOutput as an argument in your test class constructor or test method like this:
@ExtendWith(OutputCaptureExtension.class)
class MyOutputCaptureTests {
@Test
void testName(CapturedOutput output) {
System.out.println("Hello World!");
assertThat(output).contains("World");
}
}
@ExtendWith(OutputCaptureExtension::class)
class MyOutputCaptureTests {
@Test
fun testName(output: CapturedOutput?) {
println("Hello World!")
assertThat(output).contains("World")
}
}
TestRestTemplate
TestRestTemplate is a convenient alternative to Spring's RestTemplate that is useful for
integration tests. You can get a vanilla template or one that sends basic HTTP authentication (with username and
password). In any case, the template is fault-tolerant. This means that its operating logic is convenient for
testing and does not generate exceptions for errors 4xx and 5xx. Instead, such errors can be detected through the
returned ResponseEntity and its status code.
WebTestClient that is also
good for integration tests in WebFlux,
and for end-to-end testing in WebFlux and
MVC. Unlike TestRestTemplate, it provides a fluid API for adding assertions.
It is recommended - although not required - to use the Apache HTTP Client (version 4.3.2 or higher). If it is in your
classpath, the TestRestTemplate template will respond to this and configure the client accordingly. If
you are using the Apache HTTP client, some additional features are added that are useful for testing:
-
Redirects are not tracked (so you can add claims for the response location).
-
Cookies are ignored (so the template does not save state).
An instance of TestRestTemplate can be created directly in integration tests, as shown in the following
example:
class MyTests {
private final TestRestTemplate template = new TestRestTemplate();
@Test
void testRequest() {
ResponseEntity<String> headers = this.template.getForEntity("https://myhost.example.com/example", String.class);
assertThat(headers.getHeaders().getLocation()).hasHost("other.example.com");
}
}
class MyTests {
private val template = TestRestTemplate()
@Test
fun testRequest() {
val headers = template.getForEntity("https://myhost.example.com/example", String::class.java)
assertThat(headers.headers.location).hasHost("other.example.com")
}
}
Additionally, if you use the @SpringBootTest annotation with WebEnvironment.RANDOM_PORT or
WebEnvironment.DEFINED_PORT, you can inject a fully configured TestRestTemplate and start
using it. If necessary, additional settings can be applied via the RestTemplateBuilder bean. Any URLs
that do not specify a host and port are automatically connected to the built-in server, as shown in the following
example:
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class MySpringBootTests {
@Autowired
private TestRestTemplate template;
@Test
void testRequest() {
HttpHeaders headers = this.template.getForEntity("/example", String.class).getHeaders();
assertThat(headers.getLocation()).hasHost("other.example.com");
}
@TestConfiguration(proxyBeanMethods = false)
static class RestTemplateBuilderConfiguration {
@Bean
RestTemplateBuilder restTemplateBuilder() {
return new RestTemplateBuilder().setConnectTimeout(Duration.ofSeconds(1))
.setReadTimeout(Duration.ofSeconds(1));
}
}
}
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class MySpringBootTests(@Autowired val template: TestRestTemplate) {
@Test
fun testRequest() {
val headers = template.getForEntity("/example", String::class.java).headers
assertThat(headers.location).hasHost("other.example.com")
}
@TestConfiguration(proxyBeanMethods = false)
internal class RestTemplateBuilderConfiguration {
@Bean
fun restTemplateBuilder(): RestTemplateBuilder {
return RestTemplateBuilder().setConnectTimeout(Duration.ofSeconds(1))
.setReadTimeout(Duration.ofSeconds(1))
}
}
}
GO TO FULL VERSION