mockito使用

mockito学习资料：

http://docs.mockito.googlecode.com/hg/org/mockito/Mockito.html

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

​

1、验证行为是否发生

1 2 3 4 5 6 7 8

@Test public void mockedList(){     List mockedList = mock(List.class);     mockedList.add("one");     mockedList.clear();     verify(mockedList).add("one");     verify(mockedList).clear(); }

验证add和clear是否执行。

2、验证返回值

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

@Test     public void two(){         //模拟创建一个List对象         LinkedList mockLinkedList = mock(LinkedList.class);           //打桩，当LinkedList调用get（0）方法时，第一次返回zero，第二次n次返回nnnn         when(mockLinkedList.get(0)).thenReturn("zero").thenReturn("nnnn");           //使用mock对象         System.out.println(mockLinkedList.get(0));         System.out.println(mockLinkedList.get(0));         System.out.println(mockLinkedList.get(0));           //验证行为get是否发生         verify(mockLinkedList).get(0);       }

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

3、参数匹配

通过equals（）来验证参数。

不同的参数返回不同的结果：

1 2	when(comparable.compareTo("Test")).thenReturn(1);  when(comparable.compareTo("Omg")).thenReturn(2);

一旦你使用了参数匹配器，那么所有的参数都必须由匹配器给出：

1 2 3 4 5 6 7 8 9 10 11

//stubbing using built-in anyInt() argument matcher  when(mockedList.get(anyInt())).thenReturn("element");    //stubbing using hamcrest (let's say isValid() returns your own hamcrest matcher):  when(mockedList.contains(argThat(isValid()))).thenReturn("element");    //following prints "element"  System.out.println(mockedList.get(999));    //you can also verify using an argument matcher  verify(mockedList).get(anyInt());

1 2 3 4 5

verify(mock).someMethod(anyInt(), anyString(), eq("third argument"));    //above is correct - eq() is also an argument matcher      verify(mock).someMethod(anyInt(), anyString(), "third argument");    //above is incorrect - exception will be thrown because third argument is given without an argument matcher.

4、验证调用次数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

@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);     }

add(1)这个方法被调用了1次，add(2)这个被调用了2次。add(3)这个方法被调用了3次，如果将verify(mockedList,times(1)).add(3);运行后那么就会出现错误：

5、模拟方法体抛出异常

1 2 3 4 5 6

doThrow(new RuntimeException()).when(mockedList).clear();    //following throws RuntimeException: mockedList.clear();   doThrow(new RuntimeException()).when(list).add(1);  list.add(1);

6、验证执行的顺序

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

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

如果将11,12调换，

indOrder.verify(secondList).add("was called second one mock");

indOrder.verify(firstList).add("was called first one mock")；

会出现如下错误：

可是如果顺序如下：

1 2 3 4 5

firstList.add("was called first one mock"); secondList.add("was called second one mock"); InOrder indOrder = inOrder(secondList,firstList); indOrder.verify(firstList).add("was called first one mock"); indOrder.verify(secondList).add("was called second one mock");

inorder中顺序调换后，上面程序居然没有出错？难道我理解错了。验证的顺序是按照inOrder中给出的，也就是second要在first前面，而在verify中明显second在first后验证了，应该出错啊。

7、模拟对象上没有相互关系

1 2 3 4 5 6 7 8 9 10 11

//using mocks - only mockOne is interacted  mockOne.add("one");    //ordinary verification  verify(mockOne).add("one");    //verify that method was never called on a mock  verify(mockOne, never()).add("two");    //verify that other mocks were not interacted  verifyZeroInteractions(mockTwo, mockThree);

8、找出多余的调用

1 2 3 4 5 6 7 8 9 10 11 12

//using mocks  mockedList.add("one");  mockedList.add("two");    verify(mockedList).add("one");    //following verification will fail 检查是否有未被验证的行为  verifyNoMoreInteractions(mockedList);     verify(list,times(2)).add(anyInt());  //检查是否有未被验证的互动行为，因为add(1)和add(2)都会被上面的anyInt()验证到，所以下面的代码会通过     verifyNoMoreInteractions(list);

mockedList还有add（"two"）没有验证，所以出错。

9、使用注解来mock

这里注意要在构造函数中初试化mock对象，否则mock对象为null。

也可以通过在类上使用注解：@RunWith(MockitoJUnitRunner.class)

这样就不需要初始化mock了。

10、连续调用

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

@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、使用回调来stub

通用：

1 2 3 4 5 6 7 8 9 10

when(mock.someMethod(anyString())).thenAnswer(new Answer() {      Object answer(InvocationOnMock invocation) {          Object[] args = invocation.getArguments();          Object mock = invocation.getMock();          return "called with arguments: " + args;      }  });     //Following prints "called with arguments: foo"  System.out.println(mock.someMethod("foo"));

使用：

1 2 3 4 5 6 7 8 9 10 11 12

@Test     public void six(){         List mockList = mock(List.class);         when(mockList.get(anyInt())).thenAnswer(new Answer<Object>() {             public Object answer(InvocationOnMock invocation) throws Throwable {                 Object[] args = invocation.getArguments();                 return "hi:"+args[0];             }         });         assertEquals("hi:0",mockList.get(0));         assertEquals("hi:1",mockList.get(1));     }

12、对于void方法，有系列函数可以用来处理。

doThrow() doAnswer doNothing doReturn。当一个void的方法有异常抛出时可以使用doThrow()。

13、监控真实对象

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

@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语句的

1 2 3 4 5 6 7 8

List list = new LinkedList();    List spy = spy(list);         //Impossible: real method is called so spy.get(0) throws IndexOutOfBoundsException (the list is yet empty)    when(spy.get(0)).thenReturn("foo");         //You have to use doReturn() for stubbing    doReturn("foo").when(spy).get(0);

14、设置未stub的调用的默认值

对于没有stub方法的调用，我们一般返回null，或者是默认类型。也可以修改使其返回你指定的值。

1 2 3 4 5 6 7 8 9 10 11 12 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());      }