Leveraging Mock Server in Spring Boot Integration Tests

Introduction: Integration testing is crucial for ensuring the robustness and reliability of Spring Boot applications. However, testing against real external services can introduce complexity and dependencies, leading to slower and less predictable tests. In this tutorial, we'll explore how to use a Mock Server in Spring Boot integration tests to simulate external dependencies, enabling faster and more deterministic testing.

What is a Mock Server? A Mock Server is a tool that allows developers to mock HTTP services, providing a controlled environment for testing. With a Mock Server, you can define expected requests and responses, effectively simulating the behavior of real external services without actually invoking them.

Why Use Mock Server in Integration Tests? Using a Mock Server offers several benefits for integration testing in Spring Boot applications:

1. Isolation: By mocking external dependencies, you can isolate your tests from the availability and behavior of real services, ensuring consistent and reliable test results.
2. Speed: Mock Server responses are typically fast and predictable, leading to faster test execution times compared to tests that rely on real services.
3. Determinism: With predefined request-response mappings, Mock Server tests are deterministic, making it easier to reproduce and debug issues.
4. Flexibility: You can define various scenarios and edge cases by configuring different request-response mappings, allowing comprehensive test coverage.

Integration with Spring Boot: Now, let's dive into how to integrate Mock Server into Spring Boot integration tests.

1. Add Dependencies: First, add the necessary dependencies to your Spring Boot project. You'll need dependencies for both Spring Boot Test and the Mock Server library of your choice. For example, you can use WireMock or MockServer.

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>com.squareup.okhttp3</groupId>
			<artifactId>mockwebserver</artifactId>
			<version>4.5.0</version>
			<scope>test</scope>
		</dependency>

1. Configure Mock Server: Create a configuration class to initialize and configure the Mock Server instance. Define mappings for expected requests and corresponding responses.

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureWebTestClient(timeout = "100000")
@Slf4j
public class IntegrationTests {
 
private static MockWebServer mockServer;

    @DynamicPropertySource
    static void properties(DynamicPropertyRegistry registry) {
        registry.add("external.endpoint",
                () -> String.format("http://localhost:%s", mockServer.getPort()));
    }

    @BeforeAll
    static void setup() throws IOException {
        mockServer = new MockWebServer();
        mockServer.start();
    }

    @AfterAll
    static void tearDown() throws IOException {
        mockServer.shutdown();
    }

1. Write Integration Tests: Write integration tests that utilize the Mock Server to simulate external service interactions. Use the Mock Server APIs to set up expectations and verify interactions within your test methods.

protected void enqueueMockResponse(MockWebServer mockWebServer, String body) {
        val mockResponse = new MockResponse().setResponseCode(200)
                .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
                .setBody(body);
        mockWebServer.enqueue(mockResponse);
    }

    protected void enqueueMockResponse(MockWebServer mockWebServer, int status) {
        val mockResponse = new MockResponse().setResponseCode(status)
                .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
        mockWebServer.enqueue(mockResponse);
    }

    protected void enqueueMockXMLResponse(MockWebServer mockWebServer, String body) {
        val mockResponse = new MockResponse().setResponseCode(200)
                .setHeader(HttpHeaders.CONTENT_TYPE, "text/xml")
                .setBody(body);
        mockWebServer.enqueue(mockResponse);
    }

    protected void enqueueMockXMLResponse(MockWebServer mockWebServer, String body, int status) {
        val mockResponse = new MockResponse().setResponseCode(status)
                .setHeader(HttpHeaders.CONTENT_TYPE, "text/xml")
                .setBody(body);
        mockWebServer.enqueue(mockResponse);
    }

    protected void enqueueMockResponse(MockWebServer mockWebServer, String body, int status, String contentType) {
        val mockResponse = new MockResponse().setResponseCode(status)
                .setHeader(HttpHeaders.CONTENT_TYPE, contentType)
                .setBody(body);
        mockWebServer.enqueue(mockResponse);
    }

    static public String getContentFromFile(String filePath) throws IOException {
        Resource resource = new ClassPathResource(filePath);
        return IOUtils.toString(resource.getInputStream(), StandardCharsets.UTF_8);
    }

1. Run Tests: Run your integration tests, and observe the behavior of your application against the Mock Server. Verify that your application behaves as expected under various scenarios.

  enqueueMockResponse(mockServer, 403);
        int status = mockMvc.perform(post(SUMMARY_PATH)
                .header(HttpHeaders.AUTHORIZATION, "authorization")
                .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
               ...
                .content(objectMapper.writeValueAsString(req))
        ).andReturn().getResponse().getStatus();

webTestClient
                .post()
                .uri(uriBuilder -> uriBuilder
                        .build())
               
                .header(Headers.AUTHORIZATION, "authorization")
                
                .body(BodyInserters.fromValue(req))
                .exchange()
                .expectStatus()
               
                .is2xxSuccessful();

Conclusion: Integrating Mock Server into Spring Boot integration tests offers a powerful way to test your application's interactions with external dependencies in a controlled and predictable manner. By leveraging Mock Server, you can improve the speed, reliability, and flexibility of your integration tests, ultimately leading to a more robust and maintainable codebase.

Happy Testing!