Mock objects in JUnit - Build an Automation Script

Verify UserService calls UserRepository save method

Preconditions (2)

Step 1: Create a User object with name 'Alice' and email '[e-mail]'

Step 2: Call UserService.createUser with the User object

Step 3: Verify that UserRepository.save was called once with the same User object

✅ Expected Result: UserRepository.save method is called exactly once with the User object passed to UserService.createUser

Automation Requirements - JUnit 5 with Mockito

Assertions Needed:

Verify UserRepository.save called once with correct User

No other interactions with UserRepository

Best Practices:

Use @Mock and @InjectMocks annotations

Use Mockito.verify for interaction verification

Keep test method focused and clear

Automated Solution

JUnit

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
public class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    void testCreateUserCallsSave() {
        // Arrange
        User user = new User("Alice", "[e-mail]");

        // Act
        userService.createUser(user);

        // Assert
        verify(userRepository, times(1)).save(user);
        verifyNoMoreInteractions(userRepository);
    }
}

// Supporting classes for context
class User {
    private String name;
    private String email;

    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    // equals and hashCode should be overridden for correct verification
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return name.equals(user.name) && email.equals(user.email);
    }

    @Override
    public int hashCode() {
        return java.util.Objects.hash(name, email);
    }
}

interface UserRepository {
    void save(User user);
}

class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void createUser(User user) {
        userRepository.save(user);
    }
}

This test uses JUnit 5 with Mockito to check that UserService.createUser calls UserRepository.save exactly once with the correct User object.

Annotations: @Mock creates a mock UserRepository. @InjectMocks injects this mock into UserService.

Test steps: We create a User object, call createUser, then verify the mock's save method was called once with that user.

Verification: verify(userRepository, times(1)).save(user) checks the call count and argument. verifyNoMoreInteractions ensures no other calls happened.

Supporting classes: User overrides equals and hashCode so Mockito can compare objects correctly.

Common Mistakes - 4 Pitfalls

Not overriding equals and hashCode in User class

Using @Mock without @ExtendWith(MockitoExtension.class)

Verifying method call without specifying times(1)

Not verifying no more interactions

Bonus Challenge

Now add data-driven testing with 3 different User inputs to verify save is called correctly each time

Show Hint

Practice

1. What is the main purpose of using mock objects in JUnit testing?

easy

A. To speed up the compilation of test classes

B. To simulate real objects and control their behavior during tests

C. To replace the JUnit framework with a simpler tool

D. To automatically generate test data without coding

Solution

1. Step 1: Understand the role of mock objects

   Mock objects imitate real objects to isolate the code being tested and control responses.

2. Step 2: Identify the main benefit in testing

   This helps test code without relying on actual implementations or external systems.

3. Final Answer:

   To simulate real objects and control their behavior during tests -> Option B

4. Quick Check:

   Mock objects = simulate and control behavior [OK]

Hint: Mocks simulate objects to isolate tests quickly [OK]

Common Mistakes:

• Thinking mocks speed up compilation
• Confusing mocks with test data generators
• Believing mocks replace the JUnit framework

2. Which of the following is the correct way to create a mock object using Mockito in JUnit?

easy

A. MyClass mock = mock(MyClass.class);

B. MyClass mock = new MyClass().mock();

C. Mock<MyClass> mock = new Mock<>();

D. MyClass mock = createMock(MyClass);

Solution

1. Step 1: Recall Mockito syntax for creating mocks

   Mockito uses mock(Class.class) to create mock objects.

2. Step 2: Match the syntax to options

   MyClass mock = mock(MyClass.class); matches the correct syntax: MyClass mock = mock(MyClass.class);

3. Final Answer:

   MyClass mock = mock(MyClass.class); -> Option A

4. Quick Check:

   Mockito mock creation = mock(Class.class) [OK]

Hint: Use mock(Class.class) to create mocks in Mockito [OK]

Common Mistakes:

• Using new Mock<>() which is not valid
• Calling mock() on an instance
• Using createMock which is not Mockito syntax

3. Given the following code snippet, what will result be after execution?

List<String> mockList = mock(List.class);
when(mockList.size()).thenReturn(5);
int result = mockList.size();

medium

A. 5

B. 0

C. Throws NullPointerException

D. Returns the actual size of a real list

Solution

1. Step 1: Understand the mock setup

   The mock list's size() method is stubbed to return 5 when called.

2. Step 2: Evaluate the method call

   Calling mockList.size() returns 5 as per the stub, not the real list size.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Stubbed method returns set value 5 [OK]

Hint: Stubbed methods return specified values, not defaults [OK]

Common Mistakes:

• Expecting default 0 for int return
• Thinking mock calls throw exceptions by default
• Confusing mock with real object behavior

4. Identify the error in the following JUnit test code using Mockito:

MyService service = mock(MyService.class);
when(service.getData()).thenReturn("data");
verify(service).getData();

medium

A. No error, code is correct

B. Incorrect use of mock() method

C. Cannot verify void methods

D. Missing call to service.getData() before verify

Solution

1. Step 1: Understand verify usage in Mockito

   Verification checks if a method was called on the mock during the test.

2. Step 2: Check if method was called before verify

   The code never calls service.getData() before verify, so verification fails.

3. Final Answer:

   Missing call to service.getData() before verify -> Option D

4. Quick Check:

   Verify requires method call before checking [OK]

Hint: Always call method before verify to avoid errors [OK]

Common Mistakes:

• Verifying without calling the method
• Confusing mock creation syntax
• Thinking verify only works on void methods

5. You want to test a method that calls a dependency twice with different inputs and expects different outputs. How do you configure a mock to return "first" on the first call and "second" on the second call to getValue()?

hard

A. when(mock.getValue()).thenReturn("first"); when(mock.getValue()).thenReturn("second");

B. when(mock.getValue()).thenReturn(new String[]{"first", "second"});

C. when(mock.getValue()).thenReturn("first").thenReturn("second");

D. when(mock.getValue()).thenReturn("second").thenReturn("first");

Solution

1. Step 1: Recall Mockito chaining for multiple returns

   Mockito allows chaining thenReturn() calls to specify sequential return values.

2. Step 2: Match chaining syntax to options

   when(mock.getValue()).thenReturn("first").thenReturn("second"); matches the correct chaining syntax for sequential calls.

3. Final Answer:

   when(mock.getValue()).thenReturn("first").thenReturn("second"); -> Option C

4. Quick Check:

   Chain thenReturn() for multiple call returns [OK]

Hint: Chain thenReturn() calls for sequential mock returns [OK]

Common Mistakes:

• Passing multiple values in one thenReturn() call
• Overwriting stubs instead of chaining
• Reversing the order of return values