Mockito图书馆

转载：https://static.javadoc.io/org.mockito/mockito-core/2.12.0/org/mockito/Mockito.html#42

org.mockito

类Mockito

• java.lang.Object继承
• • org.mockito.ArgumentMatchers
  • • org.mockito.Mockito

• 直接已知子类：

  BDDMockito

  ---

  
  

  公共类Mockito 
  扩展了ArgumentMatchers

  Mockito图书馆可以模拟创建，验证和存根。

  这个javadoc内容也可以在http://mockito.org的网页上找到。所有的文档都保存在javadoc中，因为它保证了网页内容与源代码内容的一致性。即使脱机工作，它也允许直接从IDE访问文档。它激励Mockito开发人员随时随地记录他们编写的代码，每天都提交。

  内容

  0.迁移到Mockito 2 
  0.1 Mockito Android支持
  0.2免配置内联模拟
  1.让我们来验证一些行为！
  来自“简明英汉词典”有些残肢呢 
  3.参数匹配器
  4.验证确切的调用次数/至少一次/从不
  5.使用异常来替代void方法
  6.按顺序验证
  7.确保模拟中从未发生过交互
  8.查找多余的调用
  9.速记mocks创建 - @Mock注释
  10.连续调用连续调用（迭代器式stubbing）
  11.带回调的stubbing 
  12. doReturn()| doThrow()| doAnswer()| doNothing()| doCallRealMethod()方法家族
  13. 
  监视真实对象14.更改未打开的调用的默认返回值（从1.7开始）
  15.捕获进一步断言的参数（从1.8.0开始）
  16.实际部分模拟（从1.8.0开始）
  17.重置模拟（自1.8 0.0）
  18.故障处理及验证框架使用（由于1.8.0）
  19.别名为行为驱动开发（由于1.8.0）
  20串行化嘲笑（由于1.8.1）
  21.新的注释：@Captor，@Spy，@InjectMocks（由于1.8。 3）
  22.验证与超时（由于1.8.5）
  23的自动实例化@Spies，@InjectMocks并构造注射善（由于1.9.0）
  24.一衬垫存根（由于1.9.0）
  25.验证忽略存根（从1.9.0开始）
  26.嘲弄细节（在2.2.x中得到改进）
  27.委托实际实例的调用（从1.9.5开始）
  28. MockMakerAPI（从1.9.5开始）
  29. BDD风格验证自1.10.0）
  30.间谍或嘲笑抽象类（从2011年10月1日，在2.7.13和2.7.14进一步增强）
  31. Mockito嘲笑可以在类加载器（从1.10.0）开始序列化 / 反序列化
  32.更好的通用（从1.10.0开始）
  33. Mockito JUnit规则（从1.10.17开始）
  34. 打开或关闭插件（从1.10.15开始）
  35.自定义验证失败消息（从2.1.0开始）
  36. Java 8 Lambda Matcher支持（自2.1.0起）
  37. Java 8自定义答案支持（自2.1.0起）
  38.元数据和通用类型保留（自2.1.0起）
  39.嘲笑最终类型，枚举和最终方法（从2.1.0开始）
  40.（* new *）提高生产力和清理测试，使用更严格的Mockito（自2. +开始）
  41.（** new **）用于框架集成的高级公共API（自2.10。+起）
  42.（** new **）用于集成的新API：收听验证开始事件（自2.11。+起）
  

  0. 迁移到Mockito 2

  为了继续改进Mockito，进一步提高单元测试的体验，我们希望你升级到2.1.0！Mockito遵循 语义版本控制 ，仅在主要版本升级时才包含重大更改。在图书馆的生命周期中，突破变化是推出一系列改变现有行为甚至更改API的全新功能所必需的。有关新版本的综合指南，包括不兼容的更改，请参阅“  Mockito 2的新功能  ”wiki页面。我们希望你喜欢Mockito 2！

  0.1。Mockito Android支持

  随着Mockito版本2.6.1我们运送“原生”Android支持。要启用Android支持，请将`mockito-android`库作为依赖项添加到您的项目中。这个工件被发布到同一个Mockito组织，可以导入为Android如下：

  
   repositories {
     jcenter()
   }
   dependencies {
     testCompile "org.mockito:mockito-core:+"
     androidTestCompile "org.mockito:mockito-android:+"
   }
   

  您可以继续在常规虚拟机上运行相同的单元测试，在上面显示的“testCompile”范围内使用“mockito-core”工件。请注意，由于Android VM的限制，您无法使用Android上的 内联模拟器 。如果您在Android上遇到模拟问题，请 在官方问题跟踪器上 打开一个问题 。请提供您正在使用的Android版本和项目的相关性。

  0.2。免配置内联模拟

  从版本2.7.6开始，我们提供了“mockito-inline”工件，可以 在 不配置MockMaker扩展文件的情况下进行 内联模拟。要使用这个，添加`mockito-inline`而不是`mockito-core`神器，如下所示：

  
   repositories {
     jcenter()
   }
   dependencies {
     testCompile "org.mockito:mockito-inline:+"
   }
   

  请注意，当内联模拟功能被集成到默认模拟器中时，这个工件可能会被废除。

  有关内联模拟的更多信息，请参阅第39节。

  1. 让我们验证一些行为！

  下面的例子嘲笑一个List，因为大多数人都熟悉的界面（如  add() ， get() ， clear() 方法）。
  实际上，请不要模拟List类。改用真实的实例。

  
   //Let's import Mockito statically so that the code looks clearer
   import static org.mockito.Mockito.*;
  
   //mock creation
   List mockedList = mock(List.class);
  
   //using mock object mockedList.add("one"); mockedList.clear(); //verification verify(mockedList).add("one"); verify(mockedList).clear(); 

  一旦创建，模拟将记住所有的交互。然后，您可以选择性地验证您感兴趣的任何互动。

  来自“简明英汉词典”有些残肢呢

  
   //You can mock concrete classes, not just interfaces
   LinkedList mockedList = mock(LinkedList.class);
  
   //stubbing
   when(mockedList.get(0)).thenReturn("first");
   when(mockedList.get(1)).thenThrow(new RuntimeException()); //following prints "first" System.out.println(mockedList.get(0)); //following throws runtime exception System.out.println(mockedList.get(1)); //following prints "null" because get(999) was not stubbed System.out.println(mockedList.get(999)); //Although it is possible to verify a stubbed invocation, usually it's just redundant //If your code cares what get(0) returns, then something else breaks (often even before verify() gets executed). //If your code doesn't care what get(0) returns, then it should not be stubbed. Not convinced? See here. verify(mockedList).get(0); 

  • 默认情况下，对于返回值的所有方法，mock将根据需要返回null，原始/原始包装器值或空集合。例如，对于int / Integer为0，对于布尔值/布尔值为false。
  • 可以覆盖桩号：例如，普通桩可以进入夹具设置，但测试方法可以覆盖它。请注意，覆盖残片是一种潜在的代码异味，指出了太多的残片
  • 一旦存留，该方法总是会返回一个存根值，而不管它被调用多少次。
  • 最后的茬更重要 - 当你多次用相同的参数扼杀相同的方法。换句话说：存根的顺序很重要，但它只是很少有意义的，例如当存根完全相同的方法调用时，或者有时在使用参数匹配器时等等。

  3. 参数匹配器

  Mockito以自然的java风格验证参数值：使用 equals() 方法。有时，当需要额外的灵活性时，你可以使用参数匹配器：

  
   //stubbing using built-in anyInt() argument matcher
   when(mockedList.get(anyInt())).thenReturn("element");
  
   //stubbing using custom matcher (let's say isValid() returns your own matcher implementation):
   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()); //argument matchers can also be written as Java 8 Lambdas verify(mockedList).add(argThat(someString -> someString.length() > 5)); 

  参数匹配允许灵活的验证或存根。 查看更多内置匹配器和自定义参数匹配器/ hamcrest匹配器的示例。 Click here or here

  有关自定义参数匹配器的信息，请查看javadoc的ArgumentMatcher类。

  使用复杂的参数匹配是合理的。equals()与偶尔anyX()匹配使用的自然匹配风格倾向于给干净和简单的测试。有时候重构代码以允许equals()匹配甚至实现equals()方法来帮助进行测试会更好。

  另外，阅读第15节或javadoc的ArgumentCaptor类。 ArgumentCaptor是参数匹配器的一个特殊的实现，捕获进一步的断言的参数值。

  参数匹配器警告：

  如果使用参数匹配器，所有参数都必须由匹配器提供。

  以下示例显示验证，但同样适用于存根：

  
     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.
   

  匹配方法anyObject()，eq() 不要返回匹配器。在内部，他们在堆栈上记录匹配器并返回一个虚拟值（通常为空）。这个实现是由于Java编译器强加的静态类型的安全性。其后果是，你不能使用anyObject()，eq()验证/存根方法之外的方法。

  4. 验证调用的确切数量 / 至少x /从不

  
   //using mock
   mockedList.add("once");
  
   mockedList.add("twice");
   mockedList.add("twice");
  
   mockedList.add("three times"); mockedList.add("three times"); mockedList.add("three times"); //following two verifications work exactly the same - times(1) is used by default verify(mockedList).add("once"); verify(mockedList, times(1)).add("once"); //exact number of invocations verification verify(mockedList, times(2)).add("twice"); verify(mockedList, times(3)).add("three times"); //verification using never(). never() is an alias to times(0) verify(mockedList, never()).add("never happened"); //verification using atLeast()/atMost() verify(mockedList, atLeastOnce()).add("three times"); verify(mockedList, atLeast(2)).add("three times"); verify(mockedList, atMost(5)).add("three times"); 

  次（1）是默认值。因此明确地使用时间（1）可以省略。

  5. 使用异常来删除void方法

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

  阅读更多关于 doThrow() |  doAnswer() 家庭在方法 第12 。

   

  6. 依次验证

  
   // A. Single mock whose methods must be invoked in a particular order
   List singleMock = mock(List.class);
  
   //using a single mock
   singleMock.add("was added first");
   singleMock.add("was added second");
  
   //create an inOrder verifier for a single mock InOrder inOrder = inOrder(singleMock); //following will make sure that add is first called with "was added first, then with "was added second" inOrder.verify(singleMock).add("was added first"); inOrder.verify(singleMock).add("was added second"); // B. Multiple mocks that must be used in a particular order List firstMock = mock(List.class); List secondMock = mock(List.class); //using mocks firstMock.add("was called first"); secondMock.add("was called second"); //create inOrder object passing any mocks that need to be verified in order InOrder inOrder = inOrder(firstMock, secondMock); //following will make sure that firstMock was called before secondMock inOrder.verify(firstMock).add("was called first"); inOrder.verify(secondMock).add("was called second"); // Oh, and A + B can be mixed together at will 

  按顺序进行验证是非常灵活的 -  您不必 逐个 验证所有交互，只 需要验证您有兴趣测试的 所有交互。

  另外，您可以创建一个InOrder对象，仅传递与按序验证相关的模拟。

  7. 确保模拟中从未发生过交互

  
   //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. 找到多余的调用

  
   //using mocks
   mockedList.add("one");
   mockedList.add("two");
  
   verify(mockedList).add("one");
  
   //following verification will fail verifyNoMoreInteractions(mockedList); 

  一句 警告 ：谁做了很多经典的一些用户，期望-运行-验证嘲讽倾向于使用 verifyNoMoreInteractions() 非常频繁，甚至在每个测试方法。  verifyNoMoreInteractions() 不建议在每个测试方法中使用。 verifyNoMoreInteractions() 是交互测试工具包的一个方便的断言。只有在相关时才使用它。滥用它会导致 过度指定 ， 不易维护的 测试。你可以 在这里 找到更多的阅读 。

  另请参阅never()- 它更加明确，并充分传达意图。

   

  9. 速记嘲笑创作- @Mock注释

  • 最小化重复的模拟创建代码。
  • 使测试类更具可读性。
  • 使验证错误易于阅读，因为字段名称 用于识别模拟。

  
     public class ArticleManagerTest {
  
         @Mock private ArticleCalculator calculator; @Mock private ArticleDatabase database; @Mock private UserProvider userProvider; private ArticleManager manager; 

  重要！ 这需要在基类或测试运行的某个地方：

  
   MockitoAnnotations.initMocks(testClass);
   

  你可以使用内置的runner： MockitoJUnitRunner 或者一个规则： MockitoRule 。

  在这里阅读更多： MockitoAnnotations

  10. 连续调用（迭代器式存根）

  有时我们需要为同一个方法调用存根不同的返回值/异常。典型的用例可能是嘲讽迭代器。原始版本的Mockito没有这个功能来促进简单的嘲笑。例如，而不是迭代器可以使用 Iterable 或只是集合。那些提供自然的方式（例如使用真正的收藏）。在极少数的情况下，连续调用可能是有用的，但是：

   

  
   when(mock.someMethod("some arg"))
     .thenThrow(new RuntimeException())
     .thenReturn("foo");
  
   //First call: throws runtime exception:
   mock.someMethod("some arg"); //Second call: prints "foo" System.out.println(mock.someMethod("some arg")); //Any consecutive call: prints "foo" as well (last stubbing wins). System.out.println(mock.someMethod("some arg")); 

  可选的，连续存根的较短版本：

  
   when(mock.someMethod("some arg"))
     .thenReturn("one", "two", "three");
   

  警告 ：如果不使用链接 .thenReturn() 调用，而是使用具有相同匹配器或参数的多个存根，则每个存根将覆盖前一个存根：

  
   //All mock.someMethod("some arg") calls will return "two"
   when(mock.someMethod("some arg"))
     .thenReturn("one")
   when(mock.someMethod("some arg"))
     .thenReturn("two") 

  11. 与回调扼杀

  允许使用通用 Answer 接口存根。

  还有另一个有争议的特点，最初没有包含在Mockito中。我们建议您简单地使用stubbing，thenReturn()或者 thenThrow()应该足以测试/测试任何干净简单的代码。但是，如果您确实需要使用通用的Answer接口进行存根，请使用下面的示例：

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

  12. doReturn()| doThrow()| doAnswer()| doNothing()| doCallRealMethod()方法家族

  Stubbing void方法需要一个不同的方法， when(Object) 因为编译器不喜欢方括号内的void方法。

  使用doThrow()时要与存根异常的无效方法：

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

   

  您可以使用doThrow()，doAnswer()，doNothing()，doReturn() 和doCallRealMethod()在地方与调用相应的when()，对于任何方法。这是必要的，当你

  • 存根无效的方法
  • 间谍对象的存根方法（见下文）
  • 不止一次地存根相同的方法，在测试过程中改变模拟的行为。

  但是您可能更愿意使用这些方法替代 when() 所有您的存根呼叫。

  阅读更多关于这些方法：

  doReturn(Object)

  doThrow(Throwable...)

  doThrow(Class)

  doAnswer(Answer)

  doNothing()

  doCallRealMethod()

  13. 窥探真实的物体

  你可以创建真实对象的间谍。当你使用间谍，那么 真正的 方法被调用（除非方法被扼杀）。

  真正的间谍应该谨慎地偶尔使用，例如在处理遗留代码时。

  对真实物体的窥视可能与“部分嘲讽”概念有关。 在释放1.8之前，Mockito间谍不是真正的部分嘲讽。原因是我们认为部分模拟是一种代码味道。在某些时候，我们发现了部分模拟的合法用例（第三方接口，对遗留代码进行中间重构，整篇文章就 在这里）

   

  
     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"); 

  关于间谍真相的重要窍门！

  1. 有时使用when(Object)吝啬的间谍是不可能或不切实际的。因此，当使用间谍时，请考虑doReturn| Answer| Throw()存根方法的家庭。例：

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

  2. Mockito *不会将调用委托给传入的实例，而是实际创建一个副本。所以如果你保留真实的实例并与之交互，不要期望被侦察者知道这些交互以及它们对实际实例状态的影响。其必然结果是，当* unstubbed *方法被调用*在间谍*，但*不上真正的实例*，你不会看到真正的实例的任何影响。
  3. 留意最后的方法。Mockito不会嘲笑最后的方法，所以底线是：当你窥探真实的物体时，你试图存根最后的方法=麻烦。你也将无法验证这些方法。

  14.更改未发布的调用的默认返回值（从1.7开始）

  您可以使用指定的策略为其返回值创建一个模拟。这是一个相当先进的功能，通常你不需要它来写出体面的测试。但是，使用 遗留系统 可能会有帮助。

  这是默认的答案，所以只有当你不存在方法调用时才会使用它。

  
     Foo mock = mock(Foo.class, Mockito.RETURNS_SMART_NULLS);
     Foo mockTwo = mock(Foo.class, new YourOwnAnswer());
   

  阅读更多关于这个有趣的答案的答案：RETURNS_SMART_NULLS

  15. 捕捉参数用于进一步断言（由于1.8.0）

  Mockito以自然的java风格验证参数值：使用 equals() 方法。这也是推荐的参数匹配方式，因为它使测试变得简单明了。但是，在某些情况下，在实际验证之后对某些论点作出断言是有帮助的。例如：

  
     ArgumentCaptor argument = ArgumentCaptor.forClass(Person.class);
     verify(mock).doSomething(argument.capture());
     assertEquals("John", argument.getValue().getName());
   

  警告： 建议使用ArgumentCaptor进行验证， 但不要 使用stubbing。使用带有stub的ArgumentCaptor可能会降低测试可读性，因为在assert（也就是验证或'then'）块之外创建了捕获器。也可以减少缺陷定位，因为如果不调用stubbed方法，则不会捕获任何参数。

  ArgumentCaptor与自定义参数匹配器相关（请参阅ArgumentMatcher类javadoc ）。这两种技术都可以用来确定传递给mock的某些参数。不过，ArgumentCaptor可能更适合以下情况：

  • 自定义参数匹配器不可能被重用
  • 你只需要它来断言参数值来完成验证

  自定义参数匹配器 ArgumentMatcher 通常更适合于存根。

  16. 真正的部分模拟（自1.8.0）

  最后，在邮件列表上进行了许多内部辩论和讨论后，部分模拟支持被添加到Mockito。以前我们把部分模拟视为代码味道。但是，我们发现了部分模拟的合法用例 - 更多阅读：  这里

  在发布之前，1.8版本 spy()并没有产生真正的部分嘲讽，这让一些用户感到困惑。阅读更多关于间谍：在这里或在javadoc的spy(Object)方法。

   

  
      //you can create partial mock with spy() method:
      List list = spy(new LinkedList());
  
      //you can enable partial mock capabilities selectively on mocks:
      Foo mock = mock(Foo.class);
      //Be sure the real implementation is 'safe'.
      //If real implementation throws exceptions or depends on specific state of the object then you're in trouble. when(mock.someMethod()).thenCallRealMethod(); 

  像往常一样，您将阅读 部分模拟警告 ：面向对象的编程通过将复杂性划分为单独的，特定的SRPy对象来解决更复杂的问题。部分模拟如何适应这种模式？那么，它只是不...部分模拟通常意味着复杂性已被移动到同一个对象上的不同方法。在大多数情况下，这不是您想要设计应用程序的方式。

  但是，有些情况下，部分模拟会变得很方便：处理不能轻易更改的代码（第三方接口，传统代码的临时重构等）。但是，我不会使用部分模拟来实现新的，测试驱动的，设计的代码。

  17. 重新模拟（从1.8.0开始）

  智能Mockito用户很难使用这个功能，因为他们知道这可能是一个糟糕的测试的迹象。通常情况下，你不需要重置你的模拟，只是为每个测试方法创建新的模拟。

  不要reset()考虑写一些简单，小而重点明确的测试方法，而不要考虑冗长的，过度规定的测试。 第一个潜在的代码气味正reset()处于测试方法的中间。这可能意味着你测试太多了。按照你的测试方法的低语：“请保持我们的小而专注于单一的行为”。在mockito邮件列表上有几个线程。

  我们添加reset()方法的唯一原因是使用容器注入的模拟工作成为可能。有关更多信息，请参阅FAQ（此处）。

  不要伤害你自己 reset()在测试方法的中间是一个代码气味（你可能测试太多）。

  
     List mock = mock(List.class);
     when(mock.size()).thenReturn(10);
     mock.add(1);
  
     reset(mock);
     //at this point the mock forgot any interactions & stubbing
   

  18. 故障排除和验证框架使用（从1.8.0开始）

  首先，如果遇到任何问题，我建议您阅读Mockito FAQ： https：  //github.com/mockito/mockito/wiki/FAQ

  如有疑问，您也可以发送到mockito邮件列表：http： //groups.google.com/group/mockito

  接下来，您应该知道Mockito会验证您是否始终正确使用它。但是，有一个问题，所以请阅读javadocvalidateMockitoUsage()

  19. 行为驱动开发的别名（自1.8.0开始）

  行为驱动写作测试的开发风格使用/ /  给/ / / /然后 评论作为您的测试方法的基本部分。这正是我们如何编写测试的结果，我们热烈鼓励您这样做！

  在这里开始了解BDD：http：//en.wikipedia.org/wiki/Behavior_Driven_Development

  问题是当前stubbing api与正则表达式的时候，如果没有很好地集成//给定// // //然后评论。这是因为stubbing属于测试的给定组件，而不属于测试的when组件。因此，BDDMockito类引入了一个别名，以便您用BDDMockito.given(Object)方法存根方法调用。现在它与BDD风格测试的特定组件非常好地整合！

  以下是测试的样子：

  
   import static org.mockito.BDDMockito.*;
  
   Seller seller = mock(Seller.class);
   Shop shop = new Shop(seller);
  
   public void shouldBuyBread() throws Exception { //given given(seller.askForBread()).willReturn(new Bread()); //when Goods goods = shop.buyBread(); //then assertThat(goods, containBread()); } 

  20.可串行化的模拟（自1.8.1开始）

  嘲笑可以被序列化。有了这个特性，你可以在需要依赖的地方使用模拟器来进行序列化。

  警告：这应该很少用于单元测试。

  该行为是针对具有不可靠外部依赖性的BDD规范的特定用例实现的。这是在Web环境中，来自外部依赖项的对象正在被序列化以在层之间传递。

  要创建可串行化的模拟使用MockSettings.serializable()：

  
     List serializableMock = mock(List.class, withSettings().serializable());
   

  模拟可以被序列化，假设所有正常的 序列化要求都得到了这个类的满足。

  因为间谍（...）方法没有一个接受MockSettings的重载版本，所以制作一个真正的对象间谍序列化是一个更多的努力。不用担心，你几乎不会使用它。

  
   List