@MockBean for Spring mocking in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a mock bean for the UserService in a Spring test.

JUnit

@SpringBootTest
public class UserServiceTest {

    @[1]
    private UserService userService;

    @Test
    public void testUser() {
        // test logic here
    }
}

Drag options to blanks, or click blank then click option'

AAutowired

BInjectMocks

CMockBean

DMock

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Mock instead of @MockBean in Spring Boot tests.

Forgetting to annotate the test class with @SpringBootTest.

The @MockBean annotation creates a mock of the UserService and adds it to the Spring context for testing.

2fill in blank

medium

Complete the code to verify that the mocked UserRepository is called once in the test.

JUnit

@MockBean
private UserRepository userRepository;

@Test
public void testFindUser() {
    userService.findUserById(1L);
    verify([1]).findById(1L);
}

Drag options to blanks, or click blank then click option'

AuserRepository

BmockUserRepository

Crepository

DuserService

Attempts:

3 left

💡 Hint

Common Mistakes

Verifying the service instead of the repository mock.

Using a variable name not declared in the test.

We verify the mock userRepository to check if its findById method was called with argument 1L.

3fill in blank

hard

Fix the error in the test setup by completing the annotation to mock the EmailService bean.

JUnit

@SpringBootTest
public class NotificationTest {

    @[1]
    private EmailService emailService;

    @Test
    public void sendEmailTest() {
        when(emailService.sendEmail(anyString())).thenReturn(true);
        // test logic
    }
}

Drag options to blanks, or click blank then click option'

AMock

BMockBean

CInjectMocks

DAutowired

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Mock instead of @MockBean causing Spring context errors.

Not annotating the test class with @SpringBootTest.

Use @MockBean to mock EmailService in Spring Boot tests so Spring context uses the mock.

4fill in blank

hard

Fill both blanks to mock the PaymentService and inject the mock into OrderService.

JUnit

@SpringBootTest
public class OrderServiceTest {

    @[1]
    private PaymentService paymentService;

    @Autowired
    private OrderService orderService;

    @BeforeEach
    public void setup() {
        MockitoAnnotations.[2](this);
    }

    @Test
    public void testPayment() {
        when(paymentService.processPayment(anyDouble())).thenReturn(true);
        // test logic
    }
}

Drag options to blanks, or click blank then click option'

AMockBean

BInjectMocks

CopenMocks

DinitMocks

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Mock instead of @MockBean in Spring tests.

Using deprecated initMocks instead of openMocks.

Use @MockBean to mock PaymentService in Spring context. Use MockitoAnnotations.openMocks(this) to initialize mocks.

5fill in blank

hard

Fill all three blanks to create a mock bean for InventoryService, inject it, and verify a method call.

JUnit

@SpringBootTest
public class InventoryTest {

    @[1]
    private InventoryService inventoryService;

    @Autowired
    private InventoryController inventoryController;

    @Test
    public void testInventoryUpdate() {
        inventoryController.updateStock(5);
        verify([2]).updateStock([3]);
    }
}

Drag options to blanks, or click blank then click option'

AMockBean

BinventoryService

C5

DMock

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Mock instead of @MockBean causing Spring context issues.

Verifying the controller instead of the mock service.

Using wrong argument in verify call.

Use @MockBean to mock InventoryService. Verify the mock inventoryService received updateStock call with argument 5.

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