Note: See Maven dependencies at the end of article.

Common Mockito Methods

1. Creating Mocks

// Method 1: Using annotation (RECOMMENDED)
@Mock
BookRepository bookRepo;

// Method 2: Using mock() method
BookRepository bookRepo = mock(BookRepository.class);

2. Stubbing (Telling mock what to return)

// Return specific value
when(bookRepo.findById(100L)).thenReturn(book);

// Return different values on multiple calls
when(bookRepo.findById(anyLong()))
    .thenReturn(book1)  // First call returns book1
    .thenReturn(book2); // Second call returns book2

// Throw exception
when(bookRepo.findById(999L)).thenThrow(new RuntimeException());

// Do nothing (for void methods)
doNothing().when(bookRepo).update(any(Book.class));

3. Verification (Checking mock was used)

// Was called exactly once (default)
verify(bookRepo).findById(100L);

// Was called specific number of times
verify(bookRepo, times(2)).findById(100L); // Called twice
verify(bookRepo, atLeastOnce()).findById(100L); // At least once
verify(bookRepo, atMost(3)).findById(100L); // At most 3 times

// Was never called
verify(bookRepo, never()).findById(999L);

// Verify no more interactions
verifyNoMoreInteractions(bookRepo);

Exercise 1: Simple Calculator

// CalculatorService.java

public class CalculatorService {
    private MathOperations mathOps;

    public CalculatorService(MathOperations mathOps) {
        this.mathOps = mathOps;
    }

    public double calculateAverage(int a, int b) {
        int sum = mathOps.add(a, b);
        return mathOps.divide(sum, 2);
    }
}

// // CalculatorServiceTest.java

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

@ExtendWith(MockitoExtension.class)
public class CalculatorServiceTest {

    @Mock
    private MathOperations mathOps;

    @Test
    public void testCalculateAverage() {
        // ARRANGE
        // Program the mock
        when(mathOps.add(10, 20)).thenReturn(30);
        when(mathOps.divide(30, 2)).thenReturn(15.0);

        CalculatorService calculator = new CalculatorService(mathOps);

        // ACT
        double result = calculator.calculateAverage(10, 20);

        // ASSERT
        assertEquals(15.0, result);

        // VERIFY
        verify(mathOps).add(10, 20);
        verify(mathOps).divide(30, 2);
    }
}

The 3-Step Testing Pattern

AAA Pattern - Arrange, Act, Assert

@Test
public void testMethod() {
    // 1. ARRANGE: Setup
    @Mock Dependency dependency;
    when(dependency.method()).thenReturn(value);
    Service service = new Service(dependency);

    // 2. ACT: Execute
    Result result = service.methodToTest();

    // 3. ASSERT & VERIFY: Check
    assertEquals(expected, result);
    verify(dependency).method();
}

Most Used Methods

// CREATE
@Mock Dependency dep;                    // Create mock
Dependency dep = mock(Dependency.class); // Alternative

// STUB
when(dep.method()).thenReturn(value);    // Return value
when(dep.method()).thenThrow(exception); // Throw exception
doNothing().when(dep).voidMethod();      // Void method

// VERIFY
verify(dep).method();                    // Was called once
verify(dep, times(n)).method();          // Called n times
verify(dep, never()).method();           // Never called

// MATCHERS
any(), anyString(), anyInt()             // Match any argument
eq(value)                                // Match specific value

Exercise 2: Make Mockito Test

public class UserService {
    private UserRepository userRepo;
    private EmailService emailService;

    public UserService(UserRepository repo, EmailService email) {
        this.userRepo = repo;
        this.emailService = email;
    }

    public boolean registerUser(String email, String name) {
        // Check if email exists
        if (userRepo.findByEmail(email) != null) {
            return false; // Email already registered
        }

        // Create new user
        User user = new User();
        user.setEmail(email);
        user.setName(name);

        // Save to database
        userRepo.save(user);

        // Send welcome email
        emailService.sendWelcomeEmail(email);

        return true;
    }
}

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

@ExtendWith(MockitoExtension.class)  // This enables Mockito annotations
public class UserServiceTest {

    // Create MOCKS for dependencies
    @Mock
    private UserRepository userRepository;  // Fake database

    @Mock
    private EmailService emailService;      // Fake email service

    @Test
    public void testRegisterUser_Success() {
        // ========== 1. ARRANGE ==========
        // Setup the test scenario

        // Program the userRepository mock:
        // When findByEmail("test@example.com") is called, return null
        // (meaning email doesn't exist in database)
        when(userRepository.findByEmail("test@example.com"))
            .thenReturn(null);

        // Create the real UserService with our fake dependencies
        UserService userService = new UserService(userRepository, emailService);

        // ========== 2. ACT ==========
        // Call the method we're testing
        boolean result = userService.registerUser("test@example.com", "John Doe");

        // ========== 3. ASSERT ==========
        // Check the result
        assertTrue(result, "Registration should succeed");

        // ========== VERIFY ==========
        // Check that the mocks were used correctly

        // Verify userRepository.findByEmail was called with "test@example.com"
        verify(userRepository).findByEmail("test@example.com");

        // Verify userRepository.save was called with any User object
        verify(userRepository).save(any(User.class));

        // Verify emailService.sendWelcomeEmail was called with "test@example.com"
        verify(emailService).sendWelcomeEmail("test@example.com");
    }
}

// failure case
@Test
public void testRegisterUser_EmailAlreadyExists() {
    // ========== 1. ARRANGE ==========
    // Create an existing user
    User existingUser = new User();
    existingUser.setEmail("existing@example.com");
    existingUser.setName("Existing User");

    // Program the mock: When findByEmail is called with "existing@example.com",
    // return the existingUser (email already registered)
    when(userRepository.findByEmail("existing@example.com"))
        .thenReturn(existingUser);

    UserService userService = new UserService(userRepository, emailService);

    // ========== 2. ACT ==========
    boolean result = userService.registerUser("existing@example.com", "New User");

    // ========== 3. ASSERT ==========
    assertFalse(result, "Registration should fail when email exists");

    // ========== VERIFY ==========
    // Check findByEmail was called
    verify(userRepository).findByEmail("existing@example.com");

    // Check save was NEVER called (because registration failed)
    verify(userRepository, never()).save(any(User.class));

    // Check email was NEVER sent
    verify(emailService, never()).sendWelcomeEmail(anyString());
}

Just Remember!!

// 1. ARRANGE
when(mock.method()).thenReturn(value);

// 2. ACT 
result = service.methodUnderTest();

// 3. ASSERT & VERIFY
assertEquals(expected, result);
verify(mock).method();

SPY

Pattern 1: Spy with Real Object

// Create real object
RealClass realObj = new RealClass();

// Create spy
RealClass spy = spy(realObj);

// Mock SOME methods
doReturn("mocked").when(spy).someMethod();

Pattern 2: Spy with Class

@Spy
NotificationService spyService; // Mockito creates instance

// OR
NotificationService spy = spy(NotificationService.class);

When to Use SPY?

Use SPY when:

1. Testing legacy code that you can't refactor

2. Partially testing a class (some methods real, some mocked)

3. Testing template method pattern

4. When object has complex initialization

Use MOCK when:

1. Testing with dependencies (repositories, services)

2. Complete isolation needed

3. Most common case - 90% of tests!

Exercise 3: Using @mock, @injectMock and @spy

public class LibraryManager {
    private BookRepository bookRepo;
    private UserRepository userRepo;
    private NotificationService notifier;

    // Constructor
    public LibraryManager(BookRepository bookRepo, UserRepository userRepo, 
                         NotificationService notifier) {
        this.bookRepo = bookRepo;
        this.userRepo = userRepo;
        this.notifier = notifier;
    }

    public void borrowBook(Long userId, Long bookId) {
        User user = userRepo.findById(userId);
        Book book = bookRepo.findById(bookId);

        if (user == null || book == null || !book.isAvailable()) {
            throw new IllegalArgumentException("Cannot borrow");
        }

        book.setAvailable(false);
        bookRepo.update(book);

        notifier.sendBorrowNotification(user.getEmail(), book.getTitle());
    }
}

@ExtendWith(MockitoExtension.class)
public class LibraryManagerTest {

    @Mock
    private BookRepository bookRepo;

    @Mock
    private UserRepository userRepo;

    @Spy  // We'll use partial mocking
    private NotificationService notifier;

    @InjectMocks
    private LibraryManager libraryManager;  // Auto-injected!

    @Test
    public void testBorrowBook_Success() {
        // ========== ARRANGE ==========
        User user = new User(1L, "john@example.com");
        Book book = new Book(100L, "Mockito Guide", true);

        when(userRepo.findById(1L)).thenReturn(user);
        when(bookRepo.findById(100L)).thenReturn(book);

        // Spy: Mock only sendBorrowNotification, keep rest real
        doNothing().when(notifier).sendBorrowNotification(anyString(), anyString());

        // ========== ACT ==========
        libraryManager.borrowBook(1L, 100L);

        // ========== VERIFY ==========
        verify(bookRepo).update(book);
        assertFalse(book.isAvailable());  // State changed
        verify(notifier).sendBorrowNotification("john@example.com", "Mockito Guide");
    }
}

ArgumentCaptor

Problem:

// We can verify a method WAS called
verify(bookRepository).save(any(Book.class));

// But WHAT Book was saved? What data did it have?
// We can't check with just verify()!

Syntax:

// Step1: create the captor

// Syntax: ArgumentCaptor.forClass(ClassYouWantToCapture.class)
ArgumentCaptor<User> userCaptor = ArgumentCaptor.forClass(User.class);

// What this does:
// "Create a spy camera that captures User objects"
// It's EMPTY right now - hasn't captured anything yet

//Step2: Execute the code
userService.registerUser("John", "john@email.com", 25);

// What happens:
// 1. UserService creates a User object
// 2. UserService calls userRepo.save(user)
// 3. Our mock receives the User object

// Step3: Capture during verification
verify(userRepo).save(userCaptor.capture());

// What happens:
// 1. verify() checks save() was called
// 2. .capture() says: "Grab the argument that was passed"
// 3. The User object is stored inside userCaptor

// Step4: get and inspect
User capturedUser = userCaptor.getValue();

// Now capturedUser is THE ACTUAL User that was passed!
// We can check all its properties

Scenario: Shopping Cart Checkout

public class ShoppingCart {
    private OrderRepository orderRepo;

    public void checkout(List<Item> items) {
        for (Item item : items) {
            Order order = createOrder(item);
            orderRepo.save(order);  // Called MULTIPLE times!
        }
    }
}

@Test
public void testMultipleCaptures() {
    // ========== 1. CREATE CAPTOR ==========
    ArgumentCaptor<Order> orderCaptor = ArgumentCaptor.forClass(Order.class);

    // ========== 2. SETUP ==========
    List<Item> items = Arrays.asList(
        new Item("Book", 20.0),
        new Item("Pen", 5.0),
        new Item("Notebook", 15.0)
    );

    // ========== 3. EXECUTE ==========
    shoppingCart.checkout(items);

    // ========== 4. CAPTURE ALL CALLS ==========
    // times(3) because save() will be called 3 times
    verify(orderRepo, times(3)).save(orderCaptor.capture());

    // ========== 5. GET ALL CAPTURED VALUES ==========
    List<Order> allCapturedOrders = orderCaptor.getAllValues();

    // ========== 6. INSPECT ALL ==========
    assertEquals(3, allCapturedOrders.size());

    // Check first order
    assertEquals("Book", allCapturedOrders.get(0).getItemName());
    assertEquals(20.0, allCapturedOrders.get(0).getPrice());

    // Check second order  
    assertEquals("Pen", allCapturedOrders.get(1).getItemName());

    // Check third order
    assertEquals("Notebook", allCapturedOrders.get(2).getItemName());
}

Maven Dependencies:

<!-- JUnit 5 -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.8.2</version>
    <scope>test</scope>
</dependency>

<!-- Mockito Core -->
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>3.12.4</version>
    <scope>test</scope>
</dependency>

<!-- Mockito + JUnit 5 Integration -->
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId>
    <version>3.12.4</version>
    <scope>test</scope>
</dependency>