CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-mockito--mockito-core

Mockito mock objects library core API and implementation for comprehensive Java unit testing

—

Pending
Overview
Eval results
Files

verification.mddocs/

Verification and Assertions

This section covers verifying method invocations on mock objects, including basic verification, verification modes, ordered verification, and timeout verification.

Basic Verification

Standard Verification

Verify that methods were called on mock objects.

public static <T> T verify(T mock)
public static <T> T verify(T mock, VerificationMode mode)
public static void verifyNoMoreInteractions(Object... mocks)
public static void verifyNoInteractions(Object... mocks)

Usage Examples:

List<String> mockList = mock(List.class);

// Use mock
mockList.add("item");
mockList.clear();

// Verify method calls
verify(mockList).add("item");
verify(mockList).clear();

// Verify no additional interactions
verifyNoMoreInteractions(mockList);

// For completely unused mocks
List<String> unusedMock = mock(List.class);
verifyNoInteractions(unusedMock);

Verification Modes

Times Verification

Verify specific number of invocations.

public static VerificationMode times(int wantedNumberOfInvocations)
public static VerificationMode never()
public static VerificationMode atLeastOnce()
public static VerificationMode atLeast(int minNumberOfInvocations)
public static VerificationMode atMost(int maxNumberOfInvocations)
public static VerificationMode only()

Usage Examples:

List<String> mockList = mock(List.class);

// Use mock multiple times
mockList.add("one");
mockList.add("two");
mockList.size();

// Verify exact number of calls
verify(mockList, times(2)).add(anyString());
verify(mockList, times(1)).size();

// Verify method never called
verify(mockList, never()).clear();

// Range verifications
verify(mockList, atLeast(1)).add(anyString());
verify(mockList, atMost(3)).add(anyString());
verify(mockList, atLeastOnce()).size();

// Only this method was called (no other interactions)
List<String> singleUseMock = mock(List.class);
singleUseMock.isEmpty();
verify(singleUseMock, only()).isEmpty();

Timeout Verification

Verify method calls within a time limit, useful for asynchronous testing.

public static VerificationWithTimeout timeout(long millis)
public static VerificationAfterDelay after(long millis)

interface VerificationWithTimeout extends VerificationMode {
    VerificationWithTimeout times(int wantedNumberOfInvocations);
    VerificationWithTimeout atLeast(int minNumberOfInvocations);
    VerificationWithTimeout atMost(int maxNumberOfInvocations);
    VerificationWithTimeout only();
    VerificationWithTimeout never();
}

Usage Examples:

// Async service that calls callback
AsyncService mockService = mock(AsyncService.class);
Callback mockCallback = mock(Callback.class);

// Start async operation
mockService.processAsync(data, mockCallback);

// Verify callback is called within 1 second
verify(mockCallback, timeout(1000)).onComplete(any());

// Verify multiple calls within timeout
verify(mockCallback, timeout(2000).times(3)).onProgress(anyInt());

// Verify after delay (doesn't wait, just delays verification)
verify(mockCallback, after(100)).onComplete(any());

Ordered Verification

InOrder Verification

Verify that interactions happened in specific order.

public static InOrder inOrder(Object... mocks)

interface InOrder {
    <T> T verify(T mock);
    <T> T verify(T mock, VerificationMode mode);
    void verifyNoMoreInteractions();
}

Usage Examples:

List<String> firstMock = mock(List.class);
List<String> secondMock = mock(List.class);

// Use mocks in specific order
firstMock.add("first");
secondMock.add("second");
firstMock.add("third");

// Verify order
InOrder inOrder = inOrder(firstMock, secondMock);
inOrder.verify(firstMock).add("first");
inOrder.verify(secondMock).add("second");
inOrder.verify(firstMock).add("third");

// Verify no more interactions in order
inOrder.verifyNoMoreInteractions();

Mixed Order Verification

Combine ordered and unordered verification.

Usage Example:

List<String> mockList = mock(List.class);

mockList.add("first");
mockList.size(); // Can happen anytime
mockList.add("second");

// Verify order for specific calls
InOrder inOrder = inOrder(mockList);
inOrder.verify(mockList).add("first");
inOrder.verify(mockList).add("second");

// Verify size() was called (but order doesn't matter)
verify(mockList).size();

Advanced Verification

Custom Verification Messages

Add custom descriptions to verification failures.

interface VerificationMode {
    VerificationMode description(String description);
}

Usage Examples:

List<String> mockList = mock(List.class);

// Verification with custom error message
verify(mockList, times(1).description("Should add exactly one item"))
    .add(anyString());

// Timeout with description
verify(mockCallback, timeout(1000).description("Callback should complete within 1 second"))
    .onComplete(any());

Argument Capture for Verification

Capture arguments for detailed assertions after verification.

public static <T> ArgumentCaptor<T> captor(Class<T> clazz)

class ArgumentCaptor<T> {
    public static <T> ArgumentCaptor<T> forClass(Class<T> clazz);
    public T capture();
    public List<T> getAllValues();
    public T getValue();
}

Usage Examples:

List<String> mockList = mock(List.class);

// Use mock
mockList.add("first");
mockList.add("second");

// Capture arguments
ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
verify(mockList, times(2)).add(captor.capture());

// Assert on captured values
List<String> capturedValues = captor.getAllValues();
assertEquals("first", capturedValues.get(0));
assertEquals("second", capturedValues.get(1));

// Or just the last captured value
assertEquals("second", captor.getValue());

Ignoring Stubs for Verification

Verify only interactions that weren't stubbed.

public static Object[] ignoreStubs(Object... mocks)

Usage Example:

List<String> mockList = mock(List.class);

// Stub method
when(mockList.get(0)).thenReturn("stubbed");

// Use mock
mockList.get(0); // This is stubbed
mockList.add("item"); // This is not stubbed

// Verify ignoring stubbed interactions
verify(ignoreStubs(mockList)).add("item");
verifyNoMoreInteractions(ignoreStubs(mockList));

Verification Exception Types

Common Verification Exceptions

Understanding verification failure exceptions.

class WantedButNotInvoked extends MockitoAssertionError {
    // Thrown when expected method call didn't happen
}

class TooManyActualInvocations extends MockitoAssertionError {
    // Thrown when method called more times than expected
}

class ArgumentsAreDifferent extends MockitoAssertionError {
    // Thrown when method called with different arguments
}

class NoInteractionsWanted extends MockitoAssertionError {
    // Thrown when verifyNoInteractions() fails
}

Handling Verification Failures:

try {
    verify(mockList).add("expected");
} catch (WantedButNotInvoked e) {
    // Handle case where method wasn't called
    System.out.println("Method not called: " + e.getMessage());
}

try {
    verify(mockList, never()).clear();
} catch (MockitoAssertionError e) {
    // Handle verification failure
    System.out.println("Verification failed: " + e.getMessage());
}

Verification Best Practices

BDD-Style Verification

Using then() for behavior-driven testing (covered in detail in BDD section).

public static <T> Then<T> then(T mock)

interface Then<T> {
    BDDInOrder<T> should();
    BDDInOrder<T> should(VerificationMode mode);
    BDDInOrder<T> shouldHaveNoInteractions();
    BDDInOrder<T> shouldHaveNoMoreInteractions();
}

Usage Example:

// BDD-style verification
then(mockList).should().add("item");
then(mockList).should(times(2)).add(anyString());
then(mockList).shouldHaveNoMoreInteractions();

Install with Tessl CLI

npx tessl i tessl/maven-org-mockito--mockito-core

docs

additional-answers.md

additional-matchers.md

advanced-features.md

annotations.md

argument-matching.md

bdd-testing.md

index.md

mock-creation.md

static-mocking.md

stubbing.md

verification.md

tile.json