Spring Boot Integration Testing: The Modern Guide

Integration testing is one of the most valuable layers of the testing pyramid. Unit tests verify individual components, but integration tests validate that your application behaves correctly when multiple components interact together.

What is Integration Testing in Spring Boot?

In the Spring Boot ecosystem, integration testing typically involves starting the full Spring context using @SpringBootTest and verifying real interactions between application layers.

Integration tests commonly include:

• Controller layer (REST endpoints)
• Service layer (business logic)
• Repository layer (database interactions)
• External HTTP clients (calls to other services)

The Main Challenge: External Dependencies

External services are often the most difficult part of integration testing. Allowing tests to depend on third-party APIs such as payment providers or mapping services can introduce instability, network latency, and inconsistent results.

Traditional Approaches

Developers commonly rely on two strategies:

Mocking Internal Clients

Tools such as Mockito allow mocking HTTP client classes directly. This approach is fast but bypasses real HTTP behavior, serialization, configuration, and error handling.

HTTP Simulation Using WireMock

WireMock allows developers to simulate external HTTP services by defining expected requests and responses manually. It provides strong control over API behavior and is especially useful for contract-first or TDD workflows.

// Example WireMock simulation
@WireMockTest
class MyTest 
      @Test
      void testSomething() 
        stubFor(get("/api/resource")
        .willReturn(aResponse()
        .withStatus(200)
        .withBody("{\"id\": 1, \"name\": \"Foo\"}")));

        // Execute service logic
        
        

While WireMock is extremely powerful, manually maintaining stub data can become time-consuming as APIs evolve.

Record and Replay Testing

Another integration testing approach is record and replay. Instead of manually writing stub responses, tests capture real API interactions and reuse them later.

StableMock provides this workflow for Spring Boot integration testing.

StableMock records real HTTP interactions and converts them into WireMock-compatible stubs. It automates the creation of WireMock stubs, saving developers hours of manual work.

Step 1: Add the Dependency

<dependency>
    <groupId>io.github.stablemock</groupId>
    <artifactId>stablemock</artifactId>
    <scope>test</scope>
</dependency>

Step 2: Configure Your Test

StableMock integrates with Spring Boot tests using annotations and JUnit lifecycle hooks.

@SpringBootTest
@U(urls = "https://api.stripe.com", properties = "app.stripe.url")
class ApplicationTests extends BaseStableMockTest 

            @DynamicPropertySource
            static void configureProperties(DynamicPropertyRegistry registry) 
              autoRegisterProperties(registry, ApplicationTests.class);
              
              

Best Practices for Spring Boot Integration Tests

1. Use Real Databases: Many teams use Testcontainers to run production-like database environments during integration tests.
2. Isolate External HTTP Dependencies: Use simulation tools such as WireMock or recording tools such as StableMock, depending on your testing workflow.
3. Randomize Ports: Use webEnvironment = WebEnvironment.RANDOM_PORT to avoid conflicts in CI environments.
4. Keep Tests Independent: Avoid sharing state between tests and clean databases between executions.