Spring Boot Testing

Testing is a critical part of Spring Boot development. It ensures that your application behaves as expected, prevents regressions, and improves overall code quality. Spring Boot offers excellent built-in support for unit testing, integration testing, web layer testing, and end-to-end testing, built on top of JUnit 5, Mockito, and the Spring TestContext Framework.

What is Spring Boot Testing?

Spring Boot Testing is the process of verifying that a Spring Boot application works correctly by testing its components such as controllers, services, repositories, and security using Spring Boot’s built-in testing support.

Spring Boot provides powerful testing tools and annotations that simplify writing unit tests, integration tests, web layer tests, and end-to-end tests with minimal configuration.

In Simple Terms :

Spring Boot Testing helps catch bugs early, ensures correct behavior, and prevents breaking changes as the application evolves.

Why Spring Boot Testing Is Important

Detect bugs early in the development cycle
Ensure reliable and maintainable code
Enable safe refactoring
Verify business logic, controllers, and REST APIs
Increase confidence in production deployments

Testing is not optional—it is a core part of building robust Spring Boot applications

What Can Be Tested in Spring Boot?

Controllers – REST APIs and HTTP behavior
Services – business logic and validations
Repositories – database interactions and queries
Security – authentication & authorization rules
Integration – interaction between multiple components

Test Types in Spring Boot

Spring Boot supports multiple types of tests, and each type has a specific purpose. Using the right test type at the right place keeps your test suite fast, reliable, and maintainable.

1. Unit Testing

Unit Testing focuses on testing a single class or component in isolation, without starting the Spring container or loading the application context.

Focus

Business logic correctness
Edge cases and validations

Tools

JUnit 5 – testing framework
Mockito – mocking dependencies
@ExtendWith(MockitoExtension.class)
@Mock, @InjectMocks

Example

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    void testGetUserById() {
        User user = new User(1L, "Alice");

        Mockito.when(userRepository.findById(1L))
               .thenReturn(Optional.of(user));

        User result = userService.getUserById(1L);

        Assertions.assertEquals("Alice", result.getName());
    }
}

Unit tests verify logic, not framework behavior.

They should be fast, isolated, deterministic, and easy to maintain.

2. Integration Testing

Integration Testing verifies how multiple components work together using the Spring application context.

Focus

Service + repository interaction
Database integration
Bean wiring and configuration

Tools

@SpringBootTest
@AutoConfigureMockMvc (for web integration)
H2 (in-memory database) or Testcontainers

Example

@SpringBootTest
classUserServiceIntegrationTest {

@Autowired
private UserService userService;

@Test
voidtestUserCreation() {
Useruser=newUser(null,"Bob");
Usersaved= userService.createUser(user);

        Assertions.assertNotNull(saved.getId());
    }
}

Integration tests validate collaboration between components. They provide realistic confidence that your application works correctly as a whole.

3. Web Layer / Controller Testing

Web Layer Testing focuses on testing REST controllers and HTTP endpoints only, without loading the full Spring application context.

Focus

Request mapping correctness
HTTP status codes
Request and response structure (JSON/XML)

Tools

@WebMvcTest
MockMvc
@MockBean (to mock dependencies)

Example

@WebMvcTest(UserController.class)
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    void testGetUserEndpoint() throws Exception {
        Mockito.when(userService.getUserById(1L))
               .thenReturn(new User(1L, "John Doe"));

        mockMvc.perform(get("/api/users/1"))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.name").value("John Doe"));
    }
}

Web layer tests validate API behavior without involving business logic or databases.

They are fast, focused, and essential for REST API reliability.

4. Repository / Data Layer Testing

Repository Testing focuses on testing Spring Data JPA repositories, ensuring that database interactions work as expected.

Focus

CRUD operations
Custom JPQL / native queries
Entity mappings and relationships

Tools

@DataJpaTest
H2 in-memory database
TestEntityManager (optional, for fine-grained control)

Example

@DataJpaTest
classUserRepositoryTest {

@Autowired
private UserRepository userRepository;

@Test
voidtestFindByUsername() {
Useruser=newUser(null,"Alice");
        userRepository.save(user);

Userfound= userRepository.findByName("Alice");

        Assertions.assertNotNull(found);
    }
}

Repository tests validate database behavior, not business logic.

They provide confidence that your data layer is correctly mapped and queried.

5. End-to-End (E2E) / Full Integration Testing

End-to-End (E2E) Testing verifies the entire application flow, from incoming HTTP requests to database persistence and back to the response.

Focus

Real HTTP calls
Full Spring Application Context
Controller → Service → Repository → Database flow

Tools

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
TestRestTemplate (Blocking)
WebTestClient (Reactive / Modern)
Testcontainers (recommended for real DBs)

Example

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
classUserApiE2ETest {

@Autowired
private TestRestTemplate restTemplate;

@Test
voidtestUserCreationEndpoint() {
Useruser=newUser(null,"Charlie");

        ResponseEntity<User> response =
                restTemplate.postForEntity("/users", user, User.class);

        Assertions.assertEquals(HttpStatus.OK, response.getStatusCode());
        Assertions.assertEquals("Charlie", response.getBody().getName());
    }
}

E2E tests provide the highest confidence but should be used sparingly due to execution cost.

Other Important Testing Types

Spring Boot applications often need specialized tests beyond the typical unit, integration, and E2E tests.

1. Mocking External Services

Many applications depend on third-party APIs (e.g., payment gateways, SMS/email services).

Testing against real services can be slow, unstable, or costly.

Approach:

Use @MockBean to mock Spring beans for external clients
Use WireMock to simulate real HTTP endpoints

Benefits:

Stable and fast tests
No dependency on external services
Test both success and failure scenarios

2. Security Testing

Security testing ensures authentication and authorization rules work as intended.

Tools / Annotations:

@WithMockUser → Simulate authenticated users with roles
@WithAnonymousUser → Test access for unauthenticated users

Focus:

Role-based access control
Endpoint security
Unauthorized access prevention

Example:

@WebMvcTest(AdminController.class)
classAdminControllerTest {

@Autowired
private MockMvc mockMvc;

@Test
@WithMockUser(roles = "ADMIN")
voidadminAccessAllowed()throws Exception {
        mockMvc.perform(get("/admin/dashboard"))
               .andExpect(status().isOk());
    }

@Test
@WithAnonymousUser
voidadminAccessDeniedForAnonymous()throws Exception {
        mockMvc.perform(get("/admin/dashboard"))
               .andExpect(status().isForbidden());
    }
}

3. Async / Scheduler Testing

For applications using @Async, scheduled tasks, or CompletableFuture, testing must account for concurrency.

Approach:

Enable async support with @EnableAsync
Use CompletableFuture.get() or awaitility library to verify results
Mock dependencies to ensure isolated testing

Focus:

Validate background tasks
Ensure scheduled jobs execute correctly
Test async method results