mockito框架

2016-04-09 15:56:26

参考自

http://www.cnblogs.com/silence-hust/p/5017233.html

http://blog.csdn.net/sdyy321/article/details/38757135

首先创建一个maven工程

在pom文件中，存在如下依赖

      <dependencies>
             <dependency>
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>4.11</version>
                        <scope>test</scope>
          </dependency>
          <dependency>
              <groupId>org.mockito</groupId>
              <artifactId>mockito-all</artifactId>
              <version>1.9.5</version>
                        <scope>test</scope>
          </dependency>
      </dependencies>

1、验证行为是否发生

@Test
    public void mockedList(){
        List mockedList = mock(List.class);
        mockedList.add("one");
        mockedList.clear();
        //验证add("one")和clear()行为是否发生
        verify(mockedList).add("one");
        verify(mockedList).clear();
    }

2、验证返回值

@Test
    public void two(){
        //模拟创建一个List对象
        LinkedList mockLinkedList = mock(LinkedList.class);

        //打桩，当LinkedList调用get（0）方法时，第一次返回hello，第二次n次返回world
        when(mockLinkedList.get(0)).thenReturn("hello").thenReturn("world");
        String result = mockLinkedList.get(0) + " " + mockLinkedList.get(0) + " " + mockLinkedList.get(0);  

        //使用mock对象
        System.out.println(mockLinkedList.get(0));
        System.out.println(mockLinkedList.get(0));
        System.out.println(mockLinkedList.get(0));

        assertEquals("hello world world",result);
    } 

这里注意所有的方法都会有返回值，如果没有设置返回值，那么就会返回null或者空集、适当的类型。 Stubbing可以被重写，也就是同一个参数方法可以放回不同的值，但是以最后一次设置的值为标准。一旦被 Stubbed，无论方法被调用多少次，都只会返回Stubbed value。最后一次最重要原则。

第一次运行打印 hello world world，这是第二次运行测试打印 world world world。

3、参数匹配

@Test
    public void with_arguments(){
        Comparable comparable = mock(Comparable.class);
        //预设根据不同的参数返回不同的结果
        when(comparable.compareTo("Test")).thenReturn(1);
        when(comparable.compareTo("Omg")).thenReturn(2);
        assertEquals(1, comparable.compareTo("Test"));
        assertEquals(2, comparable.compareTo("Omg"));
        //对于没有预设的情况会返回默认值
        assertEquals(0, comparable.compareTo("Not stub"));
    }  

除了匹配给定参数外，还可以使用参数匹配器 argumentMatchers，更加灵活

@Test
    public void argumentMatchersTest(){
        List list = mock(List.class);
        //匹配任意int类型的值
        when(list.get(anyInt())).thenReturn(1);
        assertEquals(1, list.get(1));
        verify(list).get(anyInt());
        assertEquals(1, list.get(999));
    }  

若方法中的某一个参数使用了matcher，则所有的参数都必须使用matcher：

@Test
    public void argumentMatchersTest2(){
        Map map = mock(Map.class);
        //匹配任意参数
        when(map.put(anyInt(),anyString())).thenReturn("world");
        assertEquals("world", map.put(1,"hello"));
        //以下三种验证都可通过测试
        verify(map).put(anyInt(),anyString());
        verify(map).put(anyInt(),eq("hello"));
        verify(map).put(eq(1),eq("hello"));
    } 

4、验证调用次数

@Test
    public void three(){
        List mockedList = mock(List.class);
        mockedList.add(1);
        mockedList.add(2);
        mockedList.add(2);
        mockedList.add(3);
        mockedList.add(3);
        mockedList.add(3);
        //验证是否被调用一次，等效于下面的times(1)，默认的，可以不写
        verify(mockedList).add(1);
        verify(mockedList,times(1)).add(1);
        //验证是否被调用2次
        verify(mockedList,times(2)).add(2);
        //验证是否被调用3次
        verify(mockedList,times(3)).add(3);
        //验证是否从未被调用过
        verify(mockedList,never()).add(4);
        //验证至少调用一次
        verify(mockedList,atLeastOnce()).add(1);
        //验证至少调用2次
        verify(mockedList,atLeast(2)).add(2);
        //验证至多调用3次
        verify(mockedList,atMost(3)).add(3);
    }

5、模拟抛出异常

@Test(expected = IOException.class)
    public void when_thenThrow() throws IOException {
        OutputStream outputStream = mock(OutputStream.class);  //预设当流关闭时抛出异常 ，因为close()返回类型为void，采用了doThrow 形式
        doThrow(new IOException()).when(outputStream).close();
        outputStream.close();
    }
    

对于返回类型为void的方法，有系列函数可以用来处理，如doThrow， doAnswer， doNothing， doReturn。

6、验证执行的顺序

@Test
    public void four(){
        List firstList = mock(List.class);
        List secondList = mock(List.class);
        //using mocks
        firstList.add("was called first one mock");
        firstList.add("was called second one mock");
        secondList.add("was called third one mock");
        secondList.add("was called fourth one mock");
        //create inOrder object passing any mocks that need to be verified in order

       // InOrder indOrder = inOrder(firstList,secondList);
        InOrder indOrder = inOrder(secondList,firstList);
       //实际上两种顺序都通过测试了

        indOrder.verify(firstList).add("was called first one mock");
        indOrder.verify(firstList).add("was called second one mock");
        indOrder.verify(secondList).add("was called third one mock");
        indOrder.verify(secondList).add("was called fourth one mock");

    }

7、验证零互动

@Test
    public void verify_interaction(){
        List list = mock(List.class);
        List list2 = mock(List.class);
        List list3 = mock(List.class);
        list.add(1);
        verify(list).add(1);
        verify(list,never()).add(2);
        //验证零互动行为
        verifyZeroInteractions(list2,list3);
    }  

8、找出冗余的互动(即未被验证到的)

@Test
    public void find_redundant_interaction(){
        List list = mock(List.class);
        list.add(1);
        list.add(2);
        verify(list,times(2)).add(anyInt());
       //检查是否有未被验证的互动行为，因为add(1)和add(2)都会被上面的anyInt()验证到，所以下面的代码会通过
        verifyNoMoreInteractions(list);  

       //下面因为只验证了add(1)，add(2)没有被验证，所以下面的代码会失败抛出异常
       //  List list2 = mock(List.class);
       // list2.add(1);
       // list2.add(2);
       //verify(list2).add(1);
       // verifyNoMoreInteractions(list2);
    }  

9、使用注解来快速模拟

在上面的测试中我们在每个测试方法里都mock了一个List对象，为了避免重复的mock，是测试类更具有可读性，我们可以使用下面的注解方式来快速模拟对象：

public class MockDemoTest2 {
    @Mock
    private List mockList;  

    public MockDemoTest2(){
        MockitoAnnotations.initMocks(this);
    }  

    @Test
    public void shorthand(){
        mockList.add(1);
        verify(mockList).add(1);
    }
}

注意要在构造函数中初试化mock对象，否则mock对象为null。也可以通过在类上使用注解：@RunWith(MockitoJUnitRunner.class)  ，这样就不需要初始化mock了。

@RunWith(MockitoJUnitRunner.class)
public class MockDemoTest2 {

    @Mock
    private List mockList;  

   /* public MockDemoTest2(){
        MockitoAnnotations.initMocks(this);
    }
  */
    @Test
    public void shorthand(){
        mockList.add(1);
        verify(mockList).add(1);
    }  

}

10、连续调用

@Test(expected = RuntimeException.class)
    public void consecutive_calls(){
        List mockList = mock(List.class);
        //模拟连续调用返回期望值，如果分开，则只有最后一个有效
        when(mockList.get(0)).thenReturn(0);
        when(mockList.get(0)).thenReturn(1);
        when(mockList.get(0)).thenReturn(2);
        when(mockList.get(1)).thenReturn(0).thenReturn(1).thenThrow(new RuntimeException());
        assertEquals(2,mockList.get(0));
        assertEquals(2,mockList.get(0));
        assertEquals(0,mockList.get(1));
        assertEquals(1,mockList.get(1));
        //第三次或更多调用都会抛出异常
        mockList.get(1);
    }

11、使用回调生成期望值

@Test(expected = RuntimeException.class)
    public void consecutive_calls(){
        List mockList = mock(List.class);
        //模拟连续调用返回期望值，如果分开，则只有最后一个有效
        when(mockList.get(0)).thenReturn(0);
        when(mockList.get(0)).thenReturn(1);
        when(mockList.get(0)).thenReturn(2);
        when(mockList.get(1)).thenReturn(0).thenReturn(1).thenThrow(new RuntimeException());
        assertEquals(2,mockList.get(0));
        assertEquals(2,mockList.get(0));
        assertEquals(0,mockList.get(1));
        assertEquals(1,mockList.get(1));
        //第三次或更多调用都会抛出异常
        mockList.get(1);
    }

12、监控真实对象

当使用spy的时候真正的方法将会被调用，而不再是stub的对象了，这个和部分mock的思想是一样的。

@Test
    public void seven(){
        List list = new LinkedList();
        List spy = spy(list);
        //optionally, you can stub out some methods:
        when(spy.size()).thenReturn(100);
        //using the spy calls real methods
        spy.add("one");
        spy.add("two");
        //prints "one" - the first element of a list
        System.out.println(spy.get(0));
        //size() method was stubbed - 100 is printed
         System.out.println(spy.size());
        //optionally, you can verify
        verify(spy).add("one");
        verify(spy).add("two");
    }

使用spy的时候需要注意一点：有时不能用when-then语句，而改用do-when语句

@Test(expected = IndexOutOfBoundsException.class)
    public void spy_on_real_objects(){
        List list = new LinkedList();
        List spy = spy(list);
        //下面预设的spy.get(0)会报错，因为会调用真实对象的get(0)，所以会抛出越界异常
        //when(spy.get(0)).thenReturn(3);  

        //使用doReturn-when可以避免when-thenReturn调用真实对象api
        doReturn(999).when(spy).get(999);
        //预设size()期望值
        when(spy.size()).thenReturn(100);
        //调用真实对象的api
        spy.add(1);
        spy.add(2);
        assertEquals(100,spy.size());
        assertEquals(1,spy.get(0));
        assertEquals(2,spy.get(1));
        verify(spy).add(1);
        verify(spy).add(2);
        assertEquals(999,spy.get(999));
        spy.get(2);
    }  

13、修改对未预设的调用返回默认期望值

@Test
    public void eight(){
        //mock对象使用Answer来对未预设的调用返回默认期望值
        List mocklist = mock(List.class,new Answer(){
            public Object answer(InvocationOnMock invocation) throws Throwable {
                return 999;
            }
        });
        //下面的get(1)没有预设，通常情况下会返回NULL，但是使用了Answer改变了默认期望值
        assertEquals(999, mocklist.get(1));
        //下面的size()没有预设，通常情况下会返回0，但是使用了Answer改变了默认期望值
        assertEquals(999,mocklist.size());
    }

14、捕获参数来进一步断言

 @Test
 public void capturing_args(){
    PersonDao personDao = mock(PersonDao.class);
    PersonService personService = new PersonService(personDao);  

    ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
    personService.update(1,"jack");
    verify(personDao).update(argument.capture());
    assertEquals(1,argument.getValue().getId());
    assertEquals("jack",argument.getValue().getName());
}  

 class Person{
    private int id;
    private String name;  

    Person(int id, String name) {
        this.id = id;
        this.name = name;
    }  

    public int getId() {
        return id;
    }  

    public String getName() {
        return name;
    }
}  

interface PersonDao{
    public void update(Person person);
}  

class PersonService{
    private PersonDao personDao;  

    PersonService(PersonDao personDao) {
        this.personDao = personDao;
    }  

    public void update(int id,String name){
        personDao.update(new Person(id,name));
    }
} 

15、真实的部分mock

@Test
    public void real_partial_mock(){
        //通过spy来调用真实的api
        List list = spy(new ArrayList());
        assertEquals(0,list.size());
        A a  = mock(A.class);
        //通过thenCallRealMethod来调用真实的api
        when(a.doSomething(anyInt())).thenCallRealMethod();
        assertEquals(999,a.doSomething(999));
    }  

    class A{
        public int doSomething(int i){
            return i;
        }
    }
 

16、重置mock

@Test
    public void reset_mock(){
        List list = mock(List.class);
        when(list.size()).thenReturn(10);
        list.add(1);
        assertEquals(10,list.size());
        verify(list).add(1);
        //重置mock，清除所有的互动和预设
        reset(list);
        assertEquals(0,list.size());
    }