前言

Mockito 是当前最流行的 单元测试 Mock 框架。采用 Mock 框架，我们可以 虚拟 出一个 外部依赖，降低测试 组件 之间的 耦合度，只注重代码的 流程与结果，真正地实现测试目的。

正文

什么是Mock

Mock 的中文译为仿制的，模拟的，虚假的。对于测试框架来说，即构造出一个模拟/虚假的对象，使我们的测试能顺利进行下去。

Mock 测试就是在测试过程中，对于某些 不容易构造（如 HttpServletRequest 必须在 Servlet 容器中才能构造出来）或者不容易获取 比较复杂 的对象（如 JDBC 中的 ResultSet对象），用一个 虚拟 的对象（Mock 对象）来创建，以便测试方法。

为什么使用Mock测试

单元测试 是为了验证我们的代码运行正确性，我们注重的是代码的流程以及结果的正确与否。

对比真实运行代码，可能其中有一些 外部依赖 的构建步骤相对麻烦，如果我们还是按照真实代码的构建规则构造出外部依赖，会大大增加单元测试的工作，代码也会参杂太多非测试部分的内容，测试用例显得复杂难懂。

采用 Mock 框架，我们可以 虚拟 出一个 外部依赖，只注重代码的 流程与结果，真正地实现测试目的。

Mock测试框架的好处

1. 可以很简单的虚拟出一个复杂对象（比如虚拟出一个接口的实现类）；
2. 可以配置 mock 对象的行为；
3. 可以使测试用例只注重测试流程与结果；
4. 减少外部类、系统和依赖给单元测试带来的耦合。

Mockito的流程

如图所示，使用 Mockito 的大致流程如下:

1. 创建 外部依赖 的 Mock 对象, 然后将此 Mock 对象注入到 测试类 中；
2. 执行 测试代码；
3. 校验 测试代码 是否执行正确。

Mockito的使用

在 Module 的 build.gradle 中添加如下内容：

1. dependencies {

2. //Mockito for unit tests

3. testImplementation "org.mockito:mockito-core:2.+"

4. //Mockito for Android tests

5. androidTestImplementation 'org.mockito:mockito-android:2.+'

6. }

这里稍微解释下：

• mockito-core: 用于 本地单元测试，其测试代码路径位于 module-name/src/test/java/
• mockito-android: 用于 设备测试，即需要运行 android 设备进行测试，其测试代码路径位于 module-name/src/androidTest/java/

mockito-core最新版本可以在 Maven 中查询：mockito-core。 mockito-android最新版本可以在 Maven 中查询：mockito-android

Mockito的使用示例

普通单元测试使用 mockito（mockito-core），路径：module-name/src/test/java/

这里摘用官网的 Demo:

检验调对象相关行为是否被调用

1. import static org.mockito.Mockito.*;

3. // Mock creation

4. List mockedList = mock(List.class);

6. // Use mock object - it does not throw any "unexpected interaction" exception

7. mockedList.add("one"); //调用了add("one")行为

8. mockedList.clear(); //调用了clear()行为

10. // Selective, explicit, highly readable verification

11. verify(mockedList).add("one"); // 检验add("one")是否已被调用

12. verify(mockedList).clear(); // 检验clear()是否已被调用

这里 mock 了一个 List（这里只是为了用作 Demo 示例，通常对于 List 这种简单的类对象创建而言，直接 new 一个真实的对象即可，无需进行 mock），verify() 会检验对象是否在前面已经执行了相关行为，这里 mockedList 在 verify 之前已经执行了 add("one") 和 clear() 行为，所以verify() 会通过。

配置/方法行为

1. // you can mock concrete classes, not only interfaces

2. LinkedList mockedList = mock(LinkedList.class);

3. // stubbing appears before the actual execution

4. when(mockedList.get(0)).thenReturn("first");

5. // the following prints "first"

6. System.out.println(mockedList.get(0));

7. // the following prints "null" because get(999) was not stubbed

8. System.out.println(mockedList.get(999));

这里对几个比较重要的点进行解析：

when(mockedList.get(0)).thenReturn("first")

这句话 Mockito 会解析为：当对象 mockedList 调用 get()方法，并且参数为 0 时，返回结果为"first"，这相当于定制了我们 mock 对象的行为结果（mock LinkedList 对象为 mockedList，指定其行为 get(0)，则返回结果为 "first")。

mockedList.get(999)

由于 mockedList 没有指定 get(999) 的行为，所以其结果为 null。因为 Mockito 的底层原理是使用 cglib 动态生成一个 代理类对象，因此，mock 出来的对象其实质就是一个 代理，该代理在 没有配置/指定行为 的情况下，默认返回 空值。

上面的 Demo 使用的是 静态方法 mock() 模拟出一个实例，我们还可以通过注解 @Mock 也模拟出一个实例：

1. @Mock

2. private Intent mIntent;

4. @Rule

5. public MockitoRule mockitoRule = MockitoJUnit.rule();

7. @Test

8. public void mockAndroid(){

9. Intent intent = mockIntent();

10. assertThat(intent.getAction()).isEqualTo("com.yn.test.mockito");

11. assertThat(intent.getStringExtra("Name")).isEqualTo("Whyn");

12. }

14. private Intent mockIntent(){

15. when(mIntent.getAction()).thenReturn("com.yn.test.mockito");

16. when(mIntent.getStringExtra("Name")).thenReturn("Whyn");

17. return mIntent;

18. }

对于标记有 @Mock, @Spy, @InjectMocks 等注解的成员变量的 初始化 到目前为止有 2 种方法：

1. 对 JUnit 测试类添加 @RunWith(MockitoJUnitRunner.class)
2. 在标示有 @Before 方法内调用初始化方法：MockitoAnnotations.initMocks(Object)

上面的测试用例，对于 @Mock 等注解的成员变量的初始化又多了一种方式 MockitoRule。规则 MockitoRule 会自动帮我们调用 MockitoAnnotations.initMocks(this) 去 实例化 出 注解 的成员变量，我们就无需手动进行初始化了。

Mockito的重要方法

实例化虚拟对象

1. // You can mock concrete classes, not just interfaces

2. LinkedList mockedList = mock(LinkedList.class);

4. // Stubbing

5. when(mockedList.get(0)).thenReturn("first");

6. when(mockedList.get(1)).thenThrow(new RuntimeException());

8. // Following prints "first"

9. System.out.println(mockedList.get(0));

10. // Following throws runtime exception

11. System.out.println(mockedList.get(1));

12. // Following prints "null" because get(999) was not stubbed

13. System.out.println(mockedList.get(999));

15. // Although it is possible to verify a stubbed invocation, usually it's just redundant

16. // If your code cares what get(0) returns, then something else breaks (often even before verify() gets executed).

17. // If your code doesn't care what get(0) returns, then it should not be stubbed. Not convinced? See here.

18. verify(mockedList).get(0);

• 对于所有方法，mock 对象默认返回 null，原始类型/原始类型包装类 默认值，或者 空集合。比如对于 int/Integer 类型，则返回 0，对于 boolean/Boolean 则返回 false。
• 行为配置（stub）是可以被复写的：比如通常的对象行为是具有一定的配置，但是测试方法可以复写这个行为。请谨记行为复写可能表明潜在的行为太多了。
• 一旦配置了行为，方法总是会返回 配置值，无论该方法被调用了多少次。
• 最后一次行为配置是更加重要的，当你为一个带有相同参数的相同方法配置了很多次，最后一次起作用。

参数匹配

Mockito 通过参数对象的 equals() 方法来验证参数是否一致，当需要更多的灵活性时，可以使用参数匹配器：

1. // Stubbing using built-in anyInt() argument matcher

2. when(mockedList.get(anyInt())).thenReturn("element");

3. // Stubbing using custom matcher (let's say isValid() returns your own matcher implementation):

4. when(mockedList.contains(argThat(isValid()))).thenReturn("element");

5. // Following prints "element"

6. System.out.println(mockedList.get(999));

7. // You can also verify using an argument matcher

8. verify(mockedList).get(anyInt());

9. // Argument matchers can also be written as Java 8 Lambdas

10. verify(mockedList).add(argThat(someString -> someString.length() > 5));

参数匹配器 允许更加灵活的 验证 和 行为配置。更多 内置匹配器 和 自定义参数匹配器 例子请参考：ArgumentMatchers，MockitoHamcrest

注意：如果使用了参数匹配器，那么所有的参数都需要提供一个参数匹配器。

1. verify(mock).someMethod(anyInt(), anyString(), eq("third argument"));

2. // Above is correct - eq() is also an argument matcher

3. verify(mock).someMethod(anyInt(), anyString(), "third argument");

4. // Above is incorrect - exception will be thrown because third argument is given without an argument matcher.

类似 anyObject()，eq() 这类匹配器并不返回匹配数值。他们内部记录一个 匹配器堆栈 并返回一个空值（通常为 null）。这个实现是为了匹配 java 编译器的 静态类型安全，这样做的后果就是你不能在 检验/配置方法 外使用 anyObject()，eq() 等方法。

校验次数

1. LinkedList mockedList = mock(LinkedList.class);

2. // Use mock

3. mockedList.add("once");

4. mockedList.add("twice");

5. mockedList.add("twice");

6. mockedList.add("three times");

7. mockedList.add("three times");

8. mockedList.add("three times");

10. // Follow two verifications work exactly the same - times(1) is used by default

11. verify(mockedList).add("once");

12. verify(mockedList, times(1)).add("once");

14. // Exact number of invocations verification

15. verify(mockedList, times(2)).add("twice");

16. verify(mockedList, times(3)).add("three times");

18. // Verification using never(). never() is an alias to times(0)

19. verify(mockedList, never()).add("never happened");

21. // Verification using atLeast()/atMost()

22. verify(mockedList, atLeastOnce()).add("three times");

23. verify(mockedList, atLeast(2)).add("three times");

24. verify(mockedList, atMost(5)).add("three times");

校验次数方法常用的有如下几个：

|Method |Meaning| |:------|:-------| |times(n)| 次数为n，默认为1（times(1)）| |never()| 次数为0，相当于times(0)| |atLeast(n)|最少n次| |atLeastOnce()| 最少一次| |atMost(n)| 最多n次 |

抛出异常

1. doThrow(new RuntimeException()).when(mockedList).clear();

2. // following throws RuntimeException

3. mockedList.clear();

按顺序校验

有时对于一些行为，有先后顺序之分，所以，当我们在校验时，就需要考虑这个行为的先后顺序：

1. // A. Single mock whose methods must be invoked in a particular order

2. List singleMock = mock(List.class);

3. // Use a single mock

4. singleMock.add("was added first");

5. singleMock.add("was added second");

6. // Create an inOrder verifier for a single mock

7. InOrder inOrder = inOrder(singleMock);

8. // Following will make sure that add is first called with "was added first, then with "was added second"

9. inOrder.verify(singleMock).add("was added first");

10. inOrder.verify(singleMock).add("was added second");

12. // B. Multiple mocks that must be used in a particular order

13. List firstMock = mock(List.class);

14. List secondMock = mock(List.class);

15. // Use mocks

16. firstMock.add("was called first");

17. secondMock.add("was called second");

18. // Create inOrder object passing any mocks that need to be verified in order

19. InOrder inOrder = inOrder(firstMock, secondMock);

20. // Following will make sure that firstMock was called before secondMock

21. inOrder.verify(firstMock).add("was called first");

22. inOrder.verify(secondMock).add("was called second");

存根连续调用

对于同一个方法，如果我们想让其在 多次调用 中分别 返回不同 的数值，那么就可以使用存根连续调用：

1. when(mock.someMethod("some arg"))

2. .thenThrow(new RuntimeException())

3. .thenReturn("foo");

5. // First call: throws runtime exception:

6. mock.someMethod("some arg");

7. // Second call: prints "foo"

8. System.out.println(mock.someMethod("some arg"));

9. // Any consecutive call: prints "foo" as well (last stubbing wins).

10. System.out.println(mock.someMethod("some arg"));

也可以使用下面更简洁的存根连续调用方法：

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

注意：存根连续调用要求必须使用链式调用，如果使用的是同个方法的多个存根配置，那么只有最后一个起作用（覆盖前面的存根配置）。

1. // All mock.someMethod("some arg") calls will return "two"

2. when(mock.someMethod("some arg").thenReturn("one")

3. when(mock.someMethod("some arg").thenReturn("two")

无返回值函数

对于 返回类型 为 void 的方法，存根要求使用另一种形式的 when(Object) 函数，因为编译器要求括号内不能存在 void 方法。

例如，存根一个返回类型为 void 的方法，要求调用时抛出一个异常：

1. doThrow(new RuntimeException()).when(mockedList).clear();

2. // Following throws RuntimeException:

3. mockedList.clear();

监视真实对象

前面使用的都是 mock 出来一个对象。这样，当 没有配置/存根 其具体行为的话，结果就会返回 空类型。而如果使用 特务对象（spy），那么对于 没有存根 的行为，它会调用 原来对象 的方法。可以把 spy 想象成局部 mock。

1. List list = new LinkedList();

2. List spy = spy(list);

4. // Optionally, you can stub out some methods:

5. when(spy.size()).thenReturn(100);

6. // Use the spy calls *real* methods

7. spy.add("one");

8. spy.add("two");

10. // Prints "one" - the first element of a list

11. System.out.println(spy.get(0));

12. // Size() method was stubbed - 100 is printed

13. System.out.println(spy.size());

14. // Optionally, you can verify

15. verify(spy).add("one");

16. verify(spy).add("two");

注意：由于 spy 是局部 mock，所以有时候使用 when(Object) 时，无法做到存根作用。此时，就可以考虑使用 doReturn() | Answer() | Throw() 这类方法进行存根：

1. List list = new LinkedList();

2. List spy = spy(list);

3. // Impossible: real method is called so spy.get(0) throws IndexOutOfBoundsException (the list is yet empty)

4. when(spy.get(0)).thenReturn("foo");

5. // You have to use doReturn() for stubbing

6. doReturn("foo").when(spy).get(0);

spy 并不是 真实对象 的 代理。相反的，它对传递过来的 真实对象 进行 克隆。所以，对 真实对象 的任何操作，spy 对象并不会感知到。同理，对 spy 对象的任何操作，也不会影响到 真实对象。

当然，如果使用 mock 进行对象的 局部 mock，通过 doCallRealMethod() | thenCallRealMethod() 方法也是可以的：

1. // You can enable partial mock capabilities selectively on mocks:

2. Foo mock = mock(Foo.class);

3. // Be sure the real implementation is 'safe'.

4. // If real implementation throws exceptions or depends on specific state of the object then you're in trouble.

5. when(mock.someMethod()).thenCallRealMethod();

测试驱动开发

以 行为驱动开发 的格式使用 //given //when //then 注释为测试用法基石编写测试用例，这正是 Mockito 官方编写测试用例方法，强烈建议使用这种方式测试编写。

1. import static org.mockito.BDDMockito.*;

3. Seller seller = mock(Seller.class);

4. Shop shop = new Shop(seller);

6. public void shouldBuyBread() throws Exception {

7. // Given

8. given(seller.askForBread()).willReturn(new Bread());

9. // When

10. Goods goods = shop.buyBread();

11. // Then

12. assertThat(goods, containBread());

13. }

自定义错误校验输出信息

1. // Will print a custom message on verification failure

2. verify(mock, description("This will print on failure")).someMethod();

3. // Will work with any verification mode

4. verify(mock, times(2).description("someMethod should be called twice")).someMethod();

@InjectMock

构造器，方法，成员变量依赖注入 使用 @InjectMock 注解时，Mockito 会检查 类构造器，方法或 成员变量，依据它们的 类型 进行自动 mock。

1. public class InjectMockTest {

2. @Mock

3. private User user;

4. @Mock

5. private ArticleDatabase database;

6. @InjectMocks

7. private ArticleManager manager;

8. @Rule

9. public MockitoRule mockitoRule = MockitoJUnit.rule();

11. @Test

12. public void testInjectMock() {

13. // Calls addListener with an instance of ArticleListener

14. manager.initialize();

15. // Validate that addListener was called

16. verify(database).addListener(any(ArticleListener.class));

17. }

19. public static class ArticleManager {

20. private User user;

21. private ArticleDatabase database;

23. public ArticleManager(User user, ArticleDatabase database) {

24. super();

25. this.user = user;

26. this.database = database;

27. }

29. public void initialize() {

30. database.addListener(new ArticleListener());

31. }

32. }

34. public static class User {

35. }

37. public static class ArticleListener {

38. }

40. public static class ArticleDatabase {

41. public void addListener(ArticleListener listener) {

42. }

43. }

44. }

成员变量 manager 类型为 ArticleManager，它的上面标识别了 @InjectMocks。这意味着要 mock 出 manager，Mockito 需要先自动 mock 出 ArticleManager 所需的 构造参数（即：user 和 database），最终 mock 得到一个 ArticleManager，赋值给 manager。

参数捕捉

ArgumentCaptor 允许在 verify 的时候获取 方法参数内容，这使得我们能在 测试过程 中能对 调用方法参数 进行 捕捉 并 测试。

1. @Rule

2. public MockitoRule mockitoRule = MockitoJUnit.rule();

3. @Captor

4. private ArgumentCaptor<List<String>> captor;

5. @Test

6. public void testArgumentCaptor(){

7. List<String> asList = Arrays.asList("someElement_test", "someElement");

8. final List<String> mockedList = mock(List.class);

9. mockedList.addAll(asList);

11. verify(mockedList).addAll(captor.capture()); // When verify,you can capture the arguments of the calling method

12. final List<String> capturedArgument = captor.getValue();

13. assertThat(capturedArgument, hasItem("someElement"));

14. }

Mocktio的局限

1. 不能 mock 静态方法；
2. 不能 mock 构造器；
3. 不能 mockequals() 和 hashCode() 方法。

    如果我的博客对你有帮助、如果你喜欢我的博客内容，请 “点赞” “评论” “收藏” 一键三连哦！

 最后： 下方这份完整的软件测试视频教程已经整理上传完成，需要的朋友们可以自行领取【保证100%免费】