Spring Boot Testing Strategies: Unit, Integration, and Contract Tests

Published 2026-05-17 · By Shubham Bhati · Backend Engineer at AlignBits LLC

Spring Boot Testing

Published 2026-05-17 by Shubham Bhati — Backend Engineer (Java 17, Spring Boot, Microservices).

In our production environment, we've seen firsthand the impact of inadequate testing on a Spring Boot application. A recent incident where a minor change caused a cascading failure, resulting in a 30-minute downtime, highlighted the importance of thorough testing. This experience led us to re-evaluate our spring boot testing strategy, focusing on unit, integration, and contract tests to ensure our application's reliability and performance. With the latest versions of Java 21 and Spring Boot 3.2, we've been able to take advantage of new features and tools, such as JUnit 5, to improve our test coverage.

Introduction to Unit Testing
Writing Integration Tests with Spring Boot Test
Contract Testing with Spring Cloud Contract
Using Testcontainers for Isolated Testing
Common Mistakes in Spring Boot Testing
Best Practices for Test-Driven Development
FAQ
Conclusion

Introduction to Unit Testing

Unit testing is a crucial aspect of spring boot testing, allowing us to verify the behavior of individual components in isolation. With JUnit 5, we can write concise and expressive tests that cover a wide range of scenarios. For example, let's consider a simple service class that performs a calculation:

@Service
public class CalculatorService {
    public int add(int a, int b) {
        return a + b;
    }
}

We can write a unit test for this service using JUnit 5:

@ExtendWith(SpringExtension.class)
public class CalculatorServiceTest {
    @Autowired
    private CalculatorService calculatorService;

    @Test
    void testAdd() {
        int result = calculatorService.add(2, 3);
        assertEquals(5, result);
    }
}

By using @ExtendWith(SpringExtension.class), we can enable Spring support in our JUnit 5 tests.

Writing Integration Tests with Spring Boot Test

Integration tests verify the interactions between components and ensure that the application behaves as expected. Spring Boot provides the @SpringBootTest annotation to enable integration testing. Let's consider an example where we have a REST controller that depends on a service:

@RestController
public class MyController {
    @Autowired
    private MyService myService;

    @GetMapping("/data")
    public String getData() {
        return myService.getData();
    }
}

We can write an integration test for this controller using Spring Boot Test:

@SpringBootTest
@AutoConfigureMockMvc
public class MyControllerTest {
    @Autowired
    private MockMvc mockMvc;

    @Test
    void testGetData() throws Exception {
        mockMvc.perform(get("/data"))
                .andExpect(status().isOk())
                .andExpect(content().string("expected data"));
    }
}

By using @AutoConfigureMockMvc, we can enable MockMvc support in our test.

Contract Testing with Spring Cloud Contract

Contract testing ensures that the interactions between services conform to a predefined contract. Spring Cloud Contract provides a framework for writing contract tests. Let's consider an example where we have a producer service that exposes a REST API:

@RestController
public class ProducerController {
    @GetMapping("/data")
    public String getData() {
        return "producer data";
    }
}

We can write a contract test for this service using Spring Cloud Contract:

@Contract
public class ProducerContract {
    @RequestLine("GET /data")
    @ResponseLine("HTTP/1.1 200")
    @ResponseBody("producer data")
    void getData();
}

By using @Contract, we can define the contract for our service.

Using Testcontainers for Isolated Testing

Testcontainers provide a way to run isolated tests by spinning up containers for dependencies. Let's consider an example where we have a service that depends on a database:

@Service
public class MyService {
    @Autowired
    private DataSource dataSource;

    public void initData() {
        // initialize data in the database
    }
}

We can write a test for this service using Testcontainers:

@Testcontainers
public class MyServiceTest {
    @Container
    private PostgreSQLContainer<?> database = new PostgreSQLContainer<>("postgres:13")
            .withDatabaseName("mydb")
            .withUsername("myuser")
            .withPassword("mypassword");

    @Test
    void testInitData() {
        // initialize the service and verify the data
    }
}

By using @Testcontainers, we can enable Testcontainers support in our test.

Common Mistakes in Spring Boot Testing

Here are some common mistakes to avoid in spring boot testing:
* Not using the correct annotation for the test type (e.g., @Test for unit tests, @SpringBootTest for integration tests)
* Not mocking dependencies correctly
* Not using the correct test framework (e.g., JUnit 5 for unit tests, Spring Boot Test for integration tests)
* Not testing for edge cases and error scenarios
* Not using a testing library like Testcontainers for isolated testing

Best Practices for Test-Driven Development

To get the most out of test-driven development, we should follow best practices such as:
* Writing tests before writing the code
* Keeping tests simple and focused on one scenario
* Using descriptive names for tests and test methods
* Using a consistent naming convention for tests and test methods
* Running tests regularly and using a CI/CD pipeline to automate testing

FAQ

What is the difference between unit testing and integration testing?

Unit testing verifies the behavior of individual components in isolation, while integration testing verifies the interactions between components and ensures that the application behaves as expected. For more information, see the Spring documentation on testing.

How do I choose the right test framework for my Spring Boot application?

The choice of test framework depends on the type of test and the requirements of the application. For unit tests, JUnit 5 is a popular choice, while for integration tests, Spring Boot Test is a good option. For more information, see the JUnit 5 documentation.

What are some best practices for writing contract tests?

Some best practices for writing contract tests include defining a clear contract, using a consistent naming convention, and testing for edge cases and error scenarios. For more information, see the Spring Cloud Contract documentation.

How do I use Testcontainers in my Spring Boot application?

Testcontainers provide a way to run isolated tests by spinning up containers for dependencies. To use Testcontainers, add the Testcontainers dependency to your project and annotate your test class with @Testcontainers. For more information, see the Testcontainers documentation.

Conclusion

In conclusion, spring boot testing is a crucial aspect of ensuring the reliability and performance of our application. By using a combination of unit testing, integration testing, and contract testing, we can ensure that our application behaves as expected and meets the requirements of our users. By following best practices and using the right tools and frameworks, we can write effective tests that cover a wide range of scenarios and edge cases. To learn more about spring boot testing, check out the Spring documentation on testing and start writing tests for your application today.

Spring Boot Testing in production