189 8069 5689
本篇文章给大家分享的是有关如何在Java中使用Mockito测试框架，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。
创新互联公司专注为客户提供全方位的互联网综合服务，包含不限于成都网站建设、成都网站设计、湘桥网络推广、小程序开发、湘桥网络营销、湘桥企业策划、湘桥品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；创新互联公司为所有大学生创业者提供湘桥建站搭建服务，24小时服务热线：13518219792，官方网址：www.cdcxhl.com
什么是 Mock 测试
Mock 测试就是在测试过程中，对于某些不容易构造（如 HttpServletRequest 必须在Servlet 容器中才能构造出来）或者不容易获取比较复杂的对象（如 JDBC 中的ResultSet 对象），用一个虚拟的对象（Mock 对象）来创建以便测试的测试方法。
Mock 最大的功能是帮你把单元测试的耦合分解开，如果你的代码对另一个类或者接口有依赖，它能够帮你模拟这些依赖，并帮你验证所调用的依赖的行为。
比如一段代码有这样的依赖：
当我们需要测试A类的时候，如果没有 Mock，则我们需要把整个依赖树都构建出来，而使用 Mock 的话就可以将结构分解开，像下面这样：
Mock 对象使用范畴
真实对象具有不可确定的行为，产生不可预测的效果（如：股票行情，天气预报） ：
真实对象很难被创建的
真实对象的某些行为很难被触发
真实对象实际上还不存在的（和其他开发小组或者和新的硬件打交道）等等
使用 Mock 对象测试的关键步骤
使用一个接口来描述这个对象
在产品代码中实现这个接口
在测试代码中实现这个接口
在被测试代码中只是通过接口来引用对象，所以它不知道这个引用的对象是真实对象，还是 Mock 对象。
Mock 与Stub 的区别
Mock 不是 Stub，两者是有区别的：
前者被称为 mockist TDD，而后者一般称为 classic TDD ；
前者是基于行为的验证（behavior verification），后者是基于状态的验证 （state verification）；
前者使用的是模拟的对象，而后者使用的是真实的对象。
Java Mock 测试
目前，在 Java 阵营中主要的 Mock 测试工具有 Mockito，JMock，EasyMock 等。
关于这些框架的比较，不是本文的重点。本文着重介绍 Mockito 的使用。
Mockito 的特性
Mockito 是美味的 Java 单元测试 Mock 框架，开源。
大多 Java Mock 库如 EasyMock 或 JMock 都是 expect-run-verify （期望-运行-验证）方式，而 Mockito 则使用更简单，更直观的方法：在执行后的互动中提问。使用 Mockito，你可以验证任何你想要的。而那些使用 expect-run-verify 方式的库，你常常被迫查看无关的交互。
非 expect-run-verify 方式 也意味着，Mockito 无需准备昂贵的前期启动。他们的目标是透明的，让开发人员专注于测试选定的行为。
Mockito 拥有的非常少的 API，所有开始使用 Mockito，几乎没有时间成本。因为只有一种创造 mock 的方式。只要记住，在执行前 stub，而后在交互中验证。你很快就会发现这样 TDD java 代码是多么自然。
类似 EasyMock 的语法来的，所以你可以放心地重构。Mockito 并不需要“expectation（期望）”的概念。只有 stub 和验证。
Mockito 实现了 Gerard Meszaros 所谓的 Test Spy.
其他的一些特点：
可以 mock 具体类而不单止是接口
一点注解语法糖 - @Mock
干净的验证错误是 - 点击堆栈跟踪，看看在测试中的失败验证;点击异常的原因来导航到代码中的实际互动。堆栈跟踪总是干干净净。
允许灵活有序的验证（例如：你任意有序 verify，而不是每一个单独的交互）
支持“详细的用户号码的时间”以及“至少一次”验证
灵活的验证或使用参数匹配器的 stub （anyObject()，anyString() 或 refEq() 用于基于反射的相等匹配）
允许创建自定义的参数匹配器或者使用现有的 hamcrest 匹配器
Mockito 入门
声明 mockito 依赖
Gradle 用户可以使用：
repositories { jcenter() }
dependencies { testCompile "org.mockito:mockito-core:1.+" }示例
1.验证行为
//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();一旦创建 mock 将会记得所有的交互。你可以选择验证你感兴趣的任何交互
2.stubbing
//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，而对于 boolean/Boolean 就是 false。
Stubbing 可以被覆盖。
一旦 stub，该方法将始终返回一个 stub 的值，无论它有多少次被调用。
最后的 stubbing 是很重要的 - 当你使用相同的参数 stub 多次同样的方法。换句话说：stubbing 的顺序是重要的，但它唯一有意义的却很少，例如当 stubbing 完全相同的方法调用，或者有时当参数匹配器的使用，等等。
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());参数匹配器允许灵活的验证或 stubbing。点击这里查看更多内置的匹配器和自定义的参数匹配器/ hamcrest匹配器的例子。
自定义参数的匹配信息，请查看 Javadoc 中 ArgumentMatcher 类。
如果你正在使用参数的匹配，所有的参数都由匹配器来提供。
下面的示例演示验证，但同样适用于 stubbing：
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.调用额外的调用数字/at least x / never
//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("five times");
verify(mockedList, atMost(5)).add("three times");times(1) 是默认的，因此，使用的 times(1) 可以显示的省略。
5.Stubbing void 方法处理异常
doThrow(new RuntimeException()).when(mockedList).clear(); //following throws RuntimeException: mockedList.clear();
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 对象传递只与有序验证相关的 mock 。
7. 确保 mock 上不会发生交互
//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() 是从交互测试工具包一个方便的断言。只有与它的相关时才使用它。滥用它导致难以维护。
9. 标准创建 mock 方式 - 使用 @Mock 注解
最小化可重用 mock 创建代码
使测试类更加可读性
使验证错误更加易读，因为字段名称用于唯一识别 mock
public class ArticleManagerTest {
@Mock private ArticleCalculator calculator;
@Mock private ArticleDatabase database;
@Mock private UserProvider userProvider;
private ArticleManager manager;在基础类或者测试 runner 里面，使用如下：
MockitoAnnotations.initMocks(testClass);
可以使用内建 runner: MockitoJUnitRunner 或者 rule: MockitoRule
10. Stubbing 连续调用（迭代器式的 stubbing）
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");11. 回调 Stubbing
允许使用泛型 Answer 接口。
然而，这是不包括在最初的 Mockito 另一个有争议的功能。我们建议您只需用thenReturn() 或 thenThrow() 来 stubbing ，这在测试/测试驱动中应用简洁与简单的代码足够了。但是，如果你有一个需要 stub 到泛型 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) ，因为编译器不喜欢括号内无效的方法…
在 用于 Stubbing void 方法中，doThrow(Throwable…) 取代 stubVoid(Object)。主要原因是提高可读性和与 doAnswer() 保持一致性。
当你想用 stub void 方法 使用 doThrow（）：
doThrow(new RuntimeException()).when(mockedList).clear(); //following throws RuntimeException: mockedList.clear();
在调用 when() 的相应地方可以使用 oThrow(), doAnswer(), doNothing(), doReturn() 和 doCallRealMethod()，当：
stub void 方法
stub 方法在 spy 对象(见下面)
可以不止一次的 stub 相同的方法，在测试的中期来改变 mock 的行为
但你更加倾向于使用这些方法来代替 when()，在所有的 stubbing 调用。
以上就是如何在Java中使用Mockito测试框架，小编相信有部分知识点可能是我们日常工作会见到或用到的。希望你能通过这篇文章学到更多知识。更多详情敬请关注创新互联行业资讯频道。