Mockito Cheatsheet: Mock, Stub, Verify and Capture Reference

  org.mockito
  mockito-core
  5.14.2
  test


  org.mockito
  mockito-junit-jupiter     
  5.14.2
  test






dependencies {
    testImplementation("org.mockito:mockito-core:5.14.2")
    testImplementation("org.mockito:mockito-junit-jupiter:5.14.2")
}

# Use a static import for the fluent API
import static org.mockito.Mockito.*;
import static org.mockito.ArgumentMatchers.*;

# JUnit 5 wiring
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    @Mock UserRepo repo;                          // populated automatically
    @InjectMocks UserService svc;                 // constructed with the mocks
}

# Or manual init (one-liner, JUnit 4 / no extension)
@BeforeEach void init() { MockitoAnnotations.openMocks(this); }

import static org.mockito.Mockito.*;
import static org.mockito.ArgumentMatchers.*;

UserRepo repo = mock(UserRepo.class);

// 1. Simple stub
when(repo.findById(1L)).thenReturn(new User(1, "alice"));

// 2. Stage multiple returns — last one repeats
when(repo.next())
    .thenReturn(1)
    .thenReturn(2)
    .thenThrow(new IllegalStateException("drained"));

// 3. Throw on call
when(repo.findById(-1L)).thenThrow(NotFoundException.class);

// 4. Compute the answer (Answer)
when(repo.save(any())).thenAnswer(inv -> {
    User u = inv.getArgument(0);
    return u.withId(42L);                           // echo back with id
});

// 5. Void methods — use doX() forms
doThrow(new IOException()).when(repo).flush();
doNothing().when(repo).reset();
doAnswer(inv -> { log("called"); return null; }).when(repo).reset();

// 6. Spy (real object, can override per method) — doReturn() avoids running the real method
List spy = spy(new ArrayList<>());
doReturn("X").when(spy).get(0);                   // safe even when get(0) would throw

// 7. Default-return for unstubbed methods
UserRepo deep = mock(UserRepo.class, RETURNS_DEEP_STUBS);
when(deep.find().byEmail("a")).thenReturn(...);   // chained
UserRepo smart = mock(UserRepo.class, RETURNS_SMART_NULLS);  // safer null than NPE

import static org.mockito.Mockito.*;
import static org.mockito.ArgumentMatchers.*;

// 1. Verify a call happened (default = exactly once)
verify(repo).save(any(User.class));

// 2. Counts
verify(repo, times(2)).save(any());
verify(repo, never()).delete(any());
verify(repo, atLeast(1)).find(anyLong());
verify(repo, atMost(3)).find(anyLong());
verify(repo, atLeastOnce()).save(any());

// 3. Mixed: assert no further interactions
verify(repo).save(any());
verifyNoMoreInteractions(repo);                    // every call must have been verified
verifyNoInteractions(emailer);                     // nothing touched this mock

// 4. Order across mocks
InOrder order = inOrder(repo, audit);
order.verify(repo).save(any());
order.verify(audit).log(eq("user.created"));

// 5. Capture args for richer assertions
ArgumentCaptor userCap = ArgumentCaptor.forClass(User.class);
verify(repo).save(userCap.capture());
assertEquals("alice", userCap.getValue().name());

// Multi-arg capture in one go
ArgumentCaptor msg = ArgumentCaptor.forClass(String.class);
verify(audit, times(2)).log(msg.capture());
assertThat(msg.getAllValues()).containsExactly("user.created", "user.welcome");

// Or with @Captor on a field
// @Captor ArgumentCaptor cap;

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

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

@ExtendWith(MockitoExtension.class)
class CheckoutServiceTest {

    @Mock  PaymentGateway gateway;
    @Mock  InventoryRepo  inventory;
    @Mock  AuditLog       audit;
    @InjectMocks CheckoutService svc;             // ctor: (gateway, inventory, audit)

    @Captor ArgumentCaptor chargeCap;

    @Test
    void chargesAndAuditsOnSuccess() {
        when(inventory.reserve(eq("sku-1"), anyInt())).thenReturn(true);
        when(gateway.charge(any())).thenReturn(Result.ok("ch_1"));

        var receipt = svc.checkout(new Cart("sku-1", 2), "u-1");

        assertEquals("ch_1", receipt.chargeId());

        verify(inventory).reserve("sku-1", 2);
        verify(gateway).charge(chargeCap.capture());
        assertEquals(2 * 9_99, chargeCap.getValue().amountCents());

        InOrder order = inOrder(inventory, gateway, audit);
        order.verify(inventory).reserve(any(), anyInt());
        order.verify(gateway).charge(any());
        order.verify(audit).log("checkout.success", "u-1");
        verifyNoMoreInteractions(audit);
    }

    @Test
    void rollsBackWhenChargeFails() {
        when(inventory.reserve(any(), anyInt())).thenReturn(true);
        when(gateway.charge(any())).thenThrow(new GatewayException("declined"));

        assertThrows(GatewayException.class, () -> svc.checkout(new Cart("sku-1", 1), "u-1"));

        verify(inventory).release("sku-1", 1);    // rollback ran
        verify(audit).log("checkout.failure", "u-1");
    }
}