Integration Testing in Spring Boot

Overview

When we talk about integration testing for a spring boot application, it is all about running an application in ApplicationContext and run tests. Spring Framework does have a dedicated test module for integration testing. It is known as spring-test. If we are using spring-boot, then we need to use spring-boot-starter-test which will internally use spring-test and other dependent libraries. 

In this article, we are going to see how integration tests can be run for a Spring Boot application. 

@SpringBootTest

Spring-Boot provides an@SpringBootTest annotation which provides spring-boot features over and above of the spring-test module. This annotation works by creating the ApplicationContext used in our tests through SpringApplication. It starts the embedded server, creates a web environment and then enables @Test methods to do integration testing.

By default, @SpringBootTest  does not start a server. We need to add attribute webEnvironment to further refine how your tests run. It has several options:

• MOCK(Default): Loads a web ApplicationContext and provides a mock web environment
• RANDOM_PORT: Loads a WebServerApplicationContext and provides a real web environment. The embedded server is started and listen on a random port. This is the one should be used for the integration test
• DEFINED_PORT: Loads a WebServerApplicationContext and provides a real web environment.
• NONE: Loads an ApplicationContext by using SpringApplication but does not provide any web environment

In the Spring Test Framework, we used to have @ContextConfiguration annotation in order to specify which spring @Configuration to load. However, It is not required in spring-boot as it automatically searches for the primary configuration when not defined. 

If we want to customize the primary configuration, we can use a nested @TestConfiguration class in addition to the application’s primary configuration.

Application Setup 

Let's set up a simple REST API application and see how to write integration tests on it. We will be creating a Student API to create and retrieve student record and write the integration tests for the controller. 

Maven Dependency

We will be using spring-boot, spring-data, h2 in-memory DB and spring-boot test for this example:

Controller

The controller will expose createStudent() and retrieveStudent() method as REST API:

Service 

This will implement the logic to call the repository to create and retrieve the student record:

Repository

Create a spring data repository StudentRepository, which implements all the CRUD operations: 

TestRestTemplate

As explained above, for integrating testing of a spring-boot application, we need to use @SpringBootTest. spring-boot also does provide other classes like TestRestTemplate to test the REST APIs. Like RestTemplate class, it also does have methods getForObject(), postForObject(), exchange(), etc.. Lets implement @Test methods to test create and retrieve both:

In the above code, we have used WebEnvironment.RANDOM_PORT to spin up the application on random port temporarily. @LocalServerPort helps to read the current port and build the URI to hit by template class. We have used exchange() method as we want to get ResponseEntity as return type. 

@MockBean

With TestRestTemplate, we have tested all the layers from Controller to DB layer end to end. However, sometimes DB setup or third party services won't be ready and you still want to test all the application layers in your scope. That would require mocking all the external systems and services. @MockBean helps to enable the mocking of a certain layer. In this example, we will be mocking the StudentRepository:

We have used Mockito methods along with @MockBean to set the expected response.

MockMvc

There is one more approach in which server start is not required at all, but test only the layer below that. In this approach, Spring handles the incoming HTTP request and hands it off to the controller. That way, almost the full stack is used, and the code will be called exactly the same way as if it was processing a real HTTP request, but without the cost of starting the server. To do that we will use Spring’s MockMvc, and to inject that we will be using another annotation called  @AutoConfigureMockMvc. Let's implement it for both create and retrieve use case:

WebTestClient

With Spring 5, Webflux has been introduced to provide support for reactive streams. In that scenario, we would need to use WebTestClient class to test the REST API:

Conclusion

In this article, we have seen how we can do integration testing using Spring Boot test framework with the support of several different annotations.

As always, you can find the source code related to this article on GitHub.