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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Spring test with @MockBean?

Consider this Spring Boot test class using @MockBean to mock a service. What will be the printed output when the test runs?

JUnit

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import static org.mockito.BDDMockito.given;

@SpringBootTest
class UserServiceTest {

    @MockBean
    private UserRepository userRepository;

    @Autowired
    private UserService userService;

    @Test
    void testGetUserName() {
        given(userRepository.findNameById(1L)).willReturn("Alice");
        System.out.println(userService.getUserName(1L));
    }
}

@Service
class UserService {
    @Autowired
    private UserRepository userRepository;

    public String getUserName(Long id) {
        return userRepository.findNameById(id);
    }
}

interface UserRepository {
    String findNameById(Long id);
}

A null

B Alice

C Throws NullPointerException

D Compilation error due to missing bean

💡 Hint

Think about what @MockBean does and how given(...).willReturn(...) affects the mock.

The @MockBean annotation creates a mock of UserRepository and injects it into the Spring context. The given(...).willReturn("Alice") sets the mock to return "Alice" when findNameById(1L) is called. So, the userService.getUserName(1L) call prints "Alice".

❓ assertion

intermediate

Which assertion correctly verifies a mocked method call with @MockBean?

You have a @MockBean for PaymentService. Which assertion correctly verifies that processPayment() was called exactly once?

JUnit

import static org.mockito.Mockito.*;

@MockBean
PaymentService paymentService;

// In test method:
paymentService.processPayment(100);

A verify(paymentService, times(1)).processPayment(100);

B assertEquals(1, paymentService.processPayment(100));

C assertTrue(paymentService.processPayment(100));

D verify(paymentService).processPayment(anyInt());

💡 Hint

Remember how Mockito verifies method calls on mocks.

The verify() method with times(1) checks that processPayment(100) was called exactly once. Option A does not specify times(1), so it passes if called any number of times. Options A and B are incorrect because they assert return values, not method calls.

🔧 Debug

advanced

Why does this test fail with NullPointerException despite using @MockBean?

Given this test, why does it throw a NullPointerException?

JUnit

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import static org.mockito.BDDMockito.given;

@SpringBootTest
class OrderServiceTest {

    @MockBean
    private PaymentService paymentService;

    private OrderService orderService = new OrderService();

    @Test
    void testOrder() {
        given(paymentService.pay(50)).willReturn(true);
        boolean result = orderService.placeOrder(50);
        System.out.println(result);
    }
}

class OrderService {
    private PaymentService paymentService;

    public boolean placeOrder(int amount) {
        return paymentService.pay(amount);
    }
}

interface PaymentService {
    boolean pay(int amount);
}

A OrderService.paymentService is null because it is not injected by Spring

B The @MockBean annotation is missing on OrderService

C given() is called on a null object causing NullPointerException

D SpringBootTest does not support @MockBean in this context

💡 Hint

Check how the OrderService instance is created and how dependencies are injected.

The OrderService instance is created manually with new and not managed by Spring. Therefore, its paymentService field is null. The @MockBean creates a mock and injects it into Spring-managed beans only. So calling paymentService.pay() causes NullPointerException.

🧠 Conceptual

advanced

What is the main difference between @Mock and @MockBean in Spring tests?

Choose the best explanation of the difference between @Mock and @MockBean in Spring Boot testing.

A @MockBean automatically verifies method calls; @Mock requires manual verification

B @MockBean is used only for integration tests; @Mock is used only for unit tests

C @MockBean creates a spy object; @Mock creates a pure mock

D @Mock creates a mock without Spring context integration; @MockBean creates a mock and injects it into the Spring context

💡 Hint

Think about how Spring manages beans and how mocks are injected.

@Mock creates a mock object but does not integrate with Spring's application context. @MockBean creates a mock and replaces the bean in the Spring context, so Spring injects the mock wherever needed.

❓ framework

expert

Which Spring test configuration ensures @MockBean mocks are injected properly in nested test classes?

You have nested test classes inside a Spring Boot test. Which configuration ensures @MockBean mocks are injected correctly in all nested classes?

A Use @SpringBootTest only on nested classes and @MockBean only on the outer class

B Annotate each nested test class separately with @SpringBootTest and @MockBean

C Annotate the outer test class with @SpringBootTest and use @TestInstance(Lifecycle.PER_CLASS)

D Use @MockBean only in the outer class and annotate nested classes with @ExtendWith(MockitoExtension.class)

💡 Hint

Consider how Spring manages context and test instance lifecycle.

Annotating the outer class with @SpringBootTest loads the Spring context once. Using @TestInstance(Lifecycle.PER_CLASS) allows nested test classes to share the same test instance and context, so @MockBean mocks are injected properly in nested classes.

Practice

1. What is the main purpose of using @MockBean in Spring tests?

easy

A. To replace a real Spring bean with a mock during testing

B. To create a new Spring bean in the application context

C. To run the application without any beans

D. To automatically generate test data for the application

Solution

1. Step 1: Understand the role of @MockBean

   @MockBean is used to replace a real Spring bean with a mock version during tests to isolate the tested component.

2. Step 2: Compare options with the purpose

   Only To replace a real Spring bean with a mock during testing correctly describes this purpose. Other options describe unrelated behaviors.

3. Final Answer:

   To replace a real Spring bean with a mock during testing -> Option A

4. Quick Check:

   @MockBean replaces beans = A [OK]

Hint: Remember: @MockBean swaps real beans with mocks [OK]

Common Mistakes:

• Thinking @MockBean creates new beans instead of replacing
• Confusing @MockBean with test data generation
• Assuming @MockBean disables all beans

2. Which of the following is the correct way to declare a mock bean in a Spring test class?

easy

A. @Mock private MyService myService;

B. @InjectMocks private MyService myService;

C. @Autowired private MyService myService;

D. @MockBean private MyService myService;

Solution

1. Step 1: Identify the correct annotation for Spring mock beans

   @MockBean is the Spring Boot test annotation to create mock beans in the application context.

2. Step 2: Check the options

   @MockBean private MyService myService; uses @MockBean correctly. Options A and D are Mockito annotations but not for Spring context replacement. @Autowired private MyService myService; is for injecting real beans.

3. Final Answer:

   @MockBean private MyService myService; -> Option D

4. Quick Check:

   @MockBean syntax = B [OK]

Hint: Use @MockBean for Spring context mocks, not @Mock or @InjectMocks [OK]

Common Mistakes:

• Using @Mock instead of @MockBean in Spring tests
• Confusing @Autowired with mocking
• Using @InjectMocks outside Mockito context

3. Given the following test code snippet, what will be the output of myService.getData() if myService is annotated with @MockBean and no behavior is defined?

@MockBean
private MyService myService;

@Test
void test() {
    System.out.println(myService.getData());
}

medium

A. Throws NullPointerException

B. Actual data from MyService implementation

C. null

D. Empty string

Solution

1. Step 1: Understand default behavior of @MockBean mocks

   @MockBean creates a Mockito mock. By default, methods return null for objects unless stubbed.

2. Step 2: Analyze the code snippet

   No behavior is defined for getData(), so it returns null by default.

3. Final Answer:

   null -> Option C

4. Quick Check:

   Unstubbed mock method returns null = C [OK]

Hint: Unstubbed mock methods return null by default [OK]

Common Mistakes:

• Expecting real method execution instead of mock
• Assuming default return is empty string or exception
• Confusing @MockBean with real bean injection

4. Identify the error in the following Spring test class using @MockBean:

@SpringBootTest
public class UserServiceTest {

    @MockBean
    private UserRepository userRepository;

    @Test
    public void testFindUser() {
        when(userRepository.findById(1L)).thenReturn(Optional.of(new User()));
        // test logic
    }
}

medium

A. Missing @RunWith(SpringRunner.class) or @ExtendWith(SpringExtension.class)

B. No error, the code is correct

C. UserRepository should be annotated with @Autowired, not @MockBean

D. Incorrect use of when() without MockitoAnnotations.initMocks()

Solution

1. Step 1: Check Spring test setup requirements

   @SpringBootTest provides the Spring context and necessary extensions (meta-annotated with @ExtendWith(SpringExtension.class)), enabling @MockBean.

2. Step 2: Analyze the code

   @MockBean is used correctly. Stubbing with when().thenReturn() works without additional Mockito initialization in Spring Boot tests.

3. Final Answer:

   No error, the code is correct -> Option B

4. Quick Check:

   @SpringBootTest enables @MockBean = D [OK]

Hint: @SpringBootTest is sufficient for @MockBean tests [OK]

Common Mistakes:

• Thinking @RunWith or @ExtendWith is required with @SpringBootTest
• Using MockitoAnnotations.initMocks() with @MockBean
• Annotating mocks with @Autowired

5. You have a Spring service OrderService that depends on PaymentService. You want to test OrderService without calling the real PaymentService. Which approach correctly uses @MockBean to achieve this?

@SpringBootTest
public class OrderServiceTest {

    @Autowired
    private OrderService orderService;

    // What should be here?

    @Test
    public void testPlaceOrder() {
        when(paymentService.processPayment(any())).thenReturn(true);
        boolean result = orderService.placeOrder(new Order());
        assertTrue(result);
    }
}

hard

A. @MockBean
private PaymentService paymentService;

B. @Mock
private PaymentService paymentService;

C. @Autowired
private PaymentService paymentService;

D. No declaration needed; real PaymentService will be used

Solution

1. Step 1: Understand the goal

   We want to test OrderService but replace PaymentService with a mock to avoid real calls.

2. Step 2: Choose the correct annotation

   @MockBean replaces the Spring bean in the context with a mock, so @MockBean private PaymentService paymentService; is correct. @Mock is Mockito-only and won't replace Spring beans. @Autowired injects real bean. No declaration uses real service.

3. Final Answer:

   @MockBean private PaymentService paymentService; -> Option A

4. Quick Check:

   Use @MockBean to mock Spring dependencies = D [OK]

Hint: Use @MockBean to mock Spring dependencies in tests [OK]

Common Mistakes:

• Using @Mock instead of @MockBean for Spring beans
• Injecting real beans instead of mocks
• Not declaring the mock bean at all