Mockito Programming Model: Difference between revisions

From NovaOrdis Knowledge Base
Jump to navigation Jump to search
Line 84: Line 84:


===<tt>thenThrow()</tt>===
===<tt>thenThrow()</tt>===
<code>thenThrow(Throwable)</code> throws the given exception. This can be used together with JUnit feature that provides [[JUnit_Exception_Testing#.40Test_Annotation_.27expected.27_Attribute|syntactic support for tests that are supposed to check exceptions]] (<code>@Test(expected = ...)</code>).
<code>thenThrow(Throwable)</code> throws the given exception. This can be used together with JUnit feature that provides [[JUnit_Exception_Testing#.40Test_Annotation_.27expected.27_Attribute|syntactic support for tests that are supposed to check exceptions]] (<code>@Test(expected = <exception-class>)</code>).


===<tt>thenAnswer()</tt>===
===<tt>thenAnswer()</tt>===

Revision as of 17:08, 16 July 2021

Internal

Overview

API

import static org.mockito.Mockito.mock;
import com.example.ExternalDependency;

public class SomeClassTest {

  private ExternalDependency mockExternalDependency;

  @Before
  public void setUp() {
    mockExternalDependency = mock(ExternalDependency.class);
  }

  @Test
  public void someTest() throws Exception {
    ...
  }
}

Annotations

import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import com.example.ExternalDependency;

public class SomeClassTest {

  private AutoCloseable mocks;

  @Mock
  private ExternalDependency mockExternalDependency;

  @Before
  public void openMocks() {
    mocks = MockitoAnnotations.openMocks(this);
  }

  @After
  public void releaseMocks() throws Exception {
    mocks.close();
  }

  @Test
  public void someTest() throws Exception {
    ...
  }
}

Implementing Stub Functionality

A stub returns synthetic responses or throws exceptions when its methods are invoked. Mockito supports stubbing and by returning a given value when a specific method of the managed test double is called. Mockito implements the stub functionality with Mockito.when(<method>).thenReturn(...) pattern:

public class ExternalDependency {
  public String someMethod() {
    ...
  }
}
public class SomeClassTest {

  @Mock
  private ExternalDependency mockExternalDependency;

  @Test
  public void someTest() throws Exception {
    Mockito.when(mockExternalDependency.someMethod()).thenReturn("some synthetic result");
    ...
  }
}

The when() configures the method(s) to stub, or the trigger action. The then*() methods specify what to do when the trigger is activated. The options are:

Stub Responses

thenReturn()

thenReturn(...) returns the given value. It has several variants:

    • thenReturn(value): return the same value every time.
    • thenReturn(value1, value2, value3, ...): return the first value on first invocation, second value on the second invocation, etc. The equivalent is: thenReturn(value1).thenReturn(value2).thenReturn(value3). ...

thenThrow()

thenThrow(Throwable) throws the given exception. This can be used together with JUnit feature that provides syntactic support for tests that are supposed to check exceptions (@Test(expected = <exception-class>)).

thenAnswer()

thenAnswer(Answer answer): execute custom logic and compute a value to return. This turns the stub object into a fake.

thenCallRealMethod()

thenCallRealMethod(). Delegates the invocation to the real external dependency.

Argument Matchers

isA()

public class ExternalDependency {
  public String someMethodWithArg(String s) {
    ...
  }
}
import static org.mockito.ArgumentMatchers.isA;
  ...
  Mockito.when(mockExternalDependency.someMethodWithArg(isA(String.class))).thenReturn(...);
}

Why is isA() needed, why not provide the class, directly?

anyString()