【Testing】Mockito

启用Mockito注解

MockitoJUnitRunner

RunWith(MockitoJUnitRunner.class)
public class MockitoAnnotationTest {
    ...
}

MockitoAnnotations.initMocks()

@Before
public void init() {
    MockitoAnnotations.initMocks(this);
}

MockitoJUnit.rule()

public class MockitoInitWithMockitoJUnitRuleUnitTest {
    @Rule
    public MockitoRule initRule = MockitoJUnit.rule();
    ...
}

创建Mock对象

Mockito.mock()

@Test   
public void whenNotUseMockAnnotation_thenCorrect() {
    List mockList = Mockito.mock(ArrayList.class);
    mockList.add("one");
    Mockito.verify(mockList).add("one");
    assertEquals(0, mockList.size());
	
    Mockito.when(mockList.size()).thenReturn(100);
    assertEquals(100, mockList.size());
}

@Mock

@Mock
List<String> mockedList;

@Test
public void whenUseMockAnnotation_thenMockIsInjected() {
    mockedList.add("one");
    Mockito.verify(mockedList).add("one");
    assertEquals(0, mockedList.size());

    Mockito.when(mockedList.size()).thenReturn(100);
    assertEquals(100, mockedList.size());
}

创建Spy对象

Mockito.spy()

@Test
public void whenNotUseSpyAnnotation_thenCorrect() {
    List<String> spyList = Mockito.spy(new ArrayList<String>());
    spyList.add("one");
    spyList.add("two");
    Mockito.verify(spyList).add("one");
    Mockito.verify(spyList).add("two");
    assertEquals(2, spyList.size());

    Mockito.doReturn(100).when(spyList).size();
    assertEquals(100, spyList.size());
}

@Spy

// Spy对象
@Spy
List<String> spiedList = new ArrayList<String>();

@Test
public void whenUseSpyAnnotation_thenSpyIsInjectedCorrectly() {
    spiedList.add("one");
    spiedList.add("two");
    Mockito.verify(spiedList).add("one");
    Mockito.verify(spiedList).add("two");
    assertEquals(2, spiedList.size());

    Mockito.doReturn(100).when(spiedList).size();
    assertEquals(100, spiedList.size());
}

创建ArgumentCaptor对象

ArgumentCaptor.forClass()

@Test
public void whenNotUseCaptorAnnotation_thenCorrect() {
    // 手动创建Mock对象
    List mockList = Mockito.mock(List.class);
    // 手动创建参数捕获器对象
    ArgumentCaptor<String> arg = ArgumentCaptor.forClass(String.class);
    mockList.add("one");
    // 使用参数捕获器捕获add()方法传入的参数
    Mockito.verify(mockList).add(arg.capture());
    assertEquals("one", arg.getValue());
}

@Captor

// Mock对象
@Mock
List mockedList;

// 参数捕获器对象
@Captor 
ArgumentCaptor argCaptor;
@Test
public void whenUseCaptorAnnotation_thenTheSam() {
    mockedList.add("one");
    // 使用参数捕获器捕获add()方法传入的参数
    Mockito.verify(mockedList).add(argCaptor.capture());
    assertEquals("one", argCaptor.getValue());
}

@InjectMocks

使用@InjectMocks注解可以自动将Mock对象注入

// Mock对象
@Mock
Map<String, String> wordMap;
// 使用@InjectMocks注解自动将wordMap这个Mock对象注入到MyDictionary对象中
@InjectMocks
MyDictionary dic = new MyDictionary();

@Test
public void whenUseInjectMocksAnnotation_thenCorrect() {
    Mockito.when(wordMap.get("aWord")).thenReturn("aMeaning");

    assertEquals("aMeaning", dic.getMeaning("aWord"));
}

Mock对象注入到Spy对象

不像@InjectMocks一样，Mock对象无法自动注入到Spy对象。如果真的需要注入则需要使用Mockito.spy()方式手动创建Spy对象

// Mock对象
@Mock
Map<String, String> wordMap; 
// Spy对象
MyDictionary spyDic;

@Before
public void init() {
    MockitoAnnotations.initMocks(this);
    // 手动创建Spy对象，并将Mock对象通过构造方法注入
    spyDic = Mockito.spy(new MyDictionary(wordMap));
}

NPE异常模拟测试（Junit4方式）

public class MockitoAnnotationsUninitializedUnitTest {

    @Mock
    List<String> mockedList;
	// 模拟方法抛出空指针异常的情况
    @Test(expected = NullPointerException.class)
    public void whenMockitoAnnotationsUninitialized_thenNPEThrown() {
        Mockito.when(mockedList.size()).thenReturn(1);
    }
}

verify使用说明

verify方法用于验证Mock对象的方法调用，要求必须是Mock对象

验证方法单次调用

List<String> mockedList = mock(MyList.class);
mockedList.size();
// 验证Mock对象mockedList与size()方法有单次交互
verify(mockedList).size();

验证方法多次调用

List<String> mockedList = mock(MyList.class);
mockedList.size();
mockedList.size();
// 验证Mock对象mockedList与size()方法有2次交互
verify(mockedList, times(2)).size();