Discuss the use of @SpringBootTest and @MockBean annotations?

Question

Accepted Answer

@SpringBootTest and @MockBean are commonly used together in Spring Boot testing to verify application behavior while controlling dependencies. @SpringBootTest loads the complete Spring application context, whereas @MockBean replaces specific Spring beans with Mockito mocks for isolated and predictable testing.

Key Points:
• @SpringBootTest loads the full Spring Boot application context for integration testing.
• @MockBean creates and injects a Mockito mock into the Spring container.
• Using both annotations together helps test business logic without relying on external systems or databases.

Example:
Suppose we want to test OrderService, but it depends on PaymentService.

Instead of calling the actual PaymentService, we can replace it with a mock and control its behavior during the test.

Code Example:

```
@SpringBootTest
class OrderServiceTest {

@Autowired
    private OrderService orderService;

@MockBean
    private PaymentService paymentService;

@Test
    void shouldCreateOrderSuccessfully() {
```
        when(paymentService.processPayment())
```
                .thenReturn("SUCCESS");

String result =
                orderService.placeOrder();

assertEquals(
                "Order Created",
                result);
    }
}

@SpringBootTest:
```
Purpose:
• Starts the complete Spring application context.

Features:
• Loads all beans, configurations, and properties.
• Supports testing across multiple application layers.
• Useful for integration and end-to-end testing.

Common Usage:
• Testing Controller, Service, and Repository interaction.
• Verifying application startup.
• Testing security and transaction behavior.

Example:

```
@SpringBootTest
class ApplicationIntegrationTest {
}

@MockBean:
```
Purpose:
• Replaces an existing Spring bean with a Mockito mock.

Features:
• Avoids calling external systems.
• Allows controlled test scenarios.
• Improves test speed and reliability.

Common Usage:
• Mocking REST clients.
• Mocking repositories.
• Mocking third-party services.
• Mocking message brokers.

Example:

```
@MockBean
private UserRepository userRepository;
```
Comparison:

@SpringBootTest
• Loads full application context.
• Used for integration testing.
• Slower execution.

@MockBean
• Creates mock beans.
• Used for dependency isolation.
• Faster execution.

Real-World Example:

User Registration Service:

Dependencies:
• UserRepository
• EmailService
• NotificationService

During testing:

• UserRepository may use an in-memory database.
• EmailService can be replaced using @MockBean.
• NotificationService can be replaced using @MockBean.

This allows testing business logic without sending actual emails or notifications.

Best Practice:
• Use @MockBean only for external or expensive dependencies.
• Avoid loading the full context when a simple unit test is sufficient.
• Use @SpringBootTest only when interaction between multiple layers needs verification.

Interview Tip:
A concise interview answer is: @SpringBootTest loads the complete Spring Boot application context and is mainly used for integration testing. @MockBean creates a Mockito mock and replaces the actual Spring bean in the application context, allowing dependencies to be isolated during tests. Together, they help test application behavior without relying on real external systems.