@MockBean for mocking dependencies in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when @MockBean is used on a service in a Spring Boot test?

Consider a Spring Boot test class where a service is annotated with @MockBean. What is the effect of this annotation on the application context during the test?

Spring Boot

import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserServiceTest {

    @MockBean
    private UserRepository userRepository;

    // test methods
}

A The UserRepository bean is disabled and no bean is available in the test context.

B The real UserRepository bean is replaced by a Mockito mock in the test context.

C A new instance of UserRepository is created without any mocking.

D The UserRepository bean is proxied but calls go to the real implementation.

💡 Hint

Think about how Spring Boot replaces beans during testing to isolate dependencies.

The @MockBean annotation tells Spring Boot to replace the real bean with a Mockito mock. This allows tests to control and verify interactions with that dependency without using the real implementation.

📝 Syntax

intermediate

Identify the correct way to declare a @MockBean in a Spring Boot test

Which of the following code snippets correctly declares a @MockBean for a service in a Spring Boot test class?

A

@MockBean
private UserService userService;

B

@MockBean
UserService userService = new UserService();

C

@MockBean
public UserService userService() { return new UserService(); }

D

@MockBean(UserService.class)
private UserService userService;

💡 Hint

Remember how fields are annotated for mocking in Spring Boot tests.

The correct syntax is to annotate a private field with @MockBean. Option A is invalid because @MockBean does not take a class parameter like that. Options C and D are invalid because @MockBean is not used on methods or with explicit instantiation.

🔧 Debug

advanced

Why does the test fail to inject the mocked bean with @MockBean?

Given the following test code, the test fails because the mocked bean is not injected properly. What is the most likely cause?

 @SpringBootTest
public class OrderServiceTest {

    @MockBean
    private PaymentService paymentService;

    @Autowired
    private OrderService orderService;

    @Test
    public void testOrder() {
        // test logic
    }
}

A The PaymentService bean is final and cannot be mocked by Mockito.

B The @MockBean annotation is missing the required parameter to specify the bean class.

C The test class is missing @ExtendWith(MockitoExtension.class) annotation.

D The OrderService bean is not a Spring-managed bean, so injection fails.

💡 Hint

Check if the service under test is managed by Spring context.

If OrderService is not a Spring-managed bean (for example, not annotated with @Service or not scanned), Spring cannot inject the mocked PaymentService into it. The @MockBean replaces beans only in the Spring context.

❓ state_output

advanced

What is the output of the test when using @MockBean with a stubbed method?

Given the following test snippet, what will be the output printed?

 @SpringBootTest
public class GreetingServiceTest {

    @MockBean
    private TimeService timeService;

    @Autowired
    private GreetingService greetingService;

    @Test
    public void testGreeting() {
        when(timeService.getCurrentHour()).thenReturn(10);
        System.out.println(greetingService.greet());
    }
}

// GreetingService calls timeService.getCurrentHour() and returns "Good morning" if hour < 12, else "Good afternoon".

A null

B Good afternoon

C Good morning

D Throws NullPointerException

💡 Hint

Consider the stubbed return value of the mocked method.

The mocked TimeService returns 10 for getCurrentHour(), which is less than 12, so GreetingService returns "Good morning".

🧠 Conceptual

expert

Why use @MockBean instead of Mockito.mock() in Spring Boot tests?

Which of the following best explains the advantage of using @MockBean over directly creating mocks with Mockito.mock() in Spring Boot integration tests?

A @MockBean replaces the bean in the Spring application context, ensuring all dependencies receive the mock automatically.

B @MockBean creates a mock that can only be used in unit tests, not integration tests.

C Mockito.mock() automatically registers the mock in the Spring context, so @MockBean is redundant.

D @MockBean disables all other beans except the mocked one, speeding up tests.

💡 Hint

Think about how Spring manages beans and dependencies during tests.

@MockBean tells Spring to replace the real bean with a mock in the application context. This means any other bean that depends on it will get the mock injected automatically. Mockito.mock() just creates a mock object but does not integrate it into Spring's context.