• Chapter 3: 使用Mockito
    • 被测试类
    • 例子1: 不使用Mock技术
    • 例子2：使用Mockito
    • 例子3：配合Spring Test
    • 例子4：配合Spring Test（多层依赖）
    • 例子5：配合Spring Boot Test
    • 参考文档

    Chapter 3: 使用Mockito

    Mock测试技术能够避免你为了测试一个方法，却需要自行构建整个依赖关系的工作，并且能够让你专注于当前被测试对象的逻辑，而不是其依赖的其他对象的逻辑。

    举例来说，比如你需要测试Foo.methodA，而这个方法依赖了Bar.methodB，又传递依赖到了Zoo.methodC，于是它们的依赖关系就是Foo->Bar->Zoo，所以在测试代码里你必须自行new Bar和Zoo。

    有人会说：”我直接用Spring的DI机制不就行了吗？”的确，你可以用Spring的DI机制，不过解决不了测试代码耦合度过高的问题：

    因为Foo方法内部调用了Bar和Zoo的方法，所以你对其做单元测试的时候，必须完全了解Bar和Zoo方法的内部逻辑，并且谨慎的传参和assert结果，一旦Bar和Zoo的代码修改了，你的Foo测试代码很可能就会运行失败。

    所以这个时候我们需要一种机制，能过让我们在测试Foo的时候不依赖于Bar和Zoo的具体实现，即不关心其内部逻辑，只关注Foo内部的逻辑，从而将Foo的每个逻辑分支都测试到。

    所以业界就产生了Mock技术，它可以让我们做一个假的Bar（不需要Zoo，因为只有真的Bar才需要Zoo），然后控制这个假的Bar的行为（让它返回什么就返回什么），以此来测试Foo的每个逻辑分支。

    你肯定会问，这样的测试有意义吗？在真实环境里Foo用的是真的Bar而不是假的Bar，你用假的Bar测试成功能代表真实环境不出问题？

    其实假Bar代表的是一个行为正确的Bar，用它来测试就能验证”在Bar行为正确的情况下Foo的行为是否正确”，而真Bar的行为是否正确会由它自己的测试代码来验证。

    Mock技术的另一个好处是能够让你尽量避免集成测试，比如我们可以Mock一个Repository（数据库操作类），让我们尽量多写单元测试，提高测试代码执行效率。

    spring-boot-starter-test依赖了Mockito，所以我们会在本章里使用Mockito来讲解。

    被测试类

    先介绍一下接下来要被我们测试的类Foo、Bar俩兄弟。

    1. public interface Foo {
    3.   boolean checkCodeDuplicate(String code);
    5. }
    7. public interface Bar {
    9.   Set<String> getAllCodes();
    11. }
    13. @Component
    14. public class FooImpl implements Foo {
    16.   private Bar bar;
    18.   @Override
    19.   public boolean checkCodeDuplicate(String code) {
    20.     return bar.getAllCodes().contains(code);
    21.   }
    23.   @Autowired
    24.   public void setBar(Bar bar) {
    25.     this.bar = bar;
    26.   }
    28. }

    例子1: 不使用Mock技术

    源代码NoMockTest：

    1. public class NoMockTest {
    3.   @Test
    4.   public void testCheckCodeDuplicate1() throws Exception {
    6.     FooImpl foo = new FooImpl();
    7.     foo.setBar(new Bar() {
    8.       @Override
    9.       public Set<String> getAllCodes() {
    10.         return Collections.singleton("123");
    11.       }
    12.     });
    13.     assertEquals(foo.checkCodeDuplicate("123"), true);
    15.   }
    17.   @Test
    18.   public void testCheckCodeDuplicate2() throws Exception {
    20.     FooImpl foo = new FooImpl();
    21.     foo.setBar(new FakeBar(Collections.singleton("123")));
    22.     assertEquals(foo.checkCodeDuplicate("123"), true);
    24.   }
    26.   public class FakeBar implements Bar {
    28.     private final Set<String> codes;
    30.     public FakeBar(Set<String> codes) {
    31.       this.codes = codes;
    32.     }
    34.     @Override
    35.     public Set<String> getAllCodes() {
    36.       return codes;
    37.     }
    39.   }
    41. }

    这个测试代码里用到了两种方法来做假的Bar：

    1. 匿名内部类
    2. 做了一个FakeBar

    这两种方式都不是很优雅，看下面使用Mockito的例子。

    例子2：使用Mockito

    源代码[MockitoTest][src-MockitoTest]：

    1. public class MockitoTest {
    3.   @Mock
    4.   private Bar bar;
    6.   @InjectMocks
    7.   private FooImpl foo;
    9.   @BeforeMethod(alwaysRun = true)
    10.   public void initMock() {
    11.     MockitoAnnotations.initMocks(this);
    12.   }
    14.   @Test
    15.   public void testCheckCodeDuplicate() throws Exception {
    17.     when(bar.getAllCodes()).thenReturn(Collections.singleton("123"));
    18.     assertEquals(foo.checkCodeDuplicate("123"), true);
    20.   }
    22. }
    1. 我们先给了一个Bar的Mock实现：@Mock private Bar bar;
    2. 然后又规定了getAllCodes方法的返回值：when(bar.getAllCodes()).thenReturn(Collections.singleton("123"))。这样就把一个假的Bar定义好了。
    3. 最后利用Mockito把Bar注入到Foo里面，@InjectMocks private FooImpl foo;、MockitoAnnotations.initMocks(this);

    例子3：配合Spring Test

    源代码Spring_1_Test：

    1. @ContextConfiguration(classes = FooImpl.class)
    2. @TestExecutionListeners(listeners = MockitoTestExecutionListener.class)
    3. public class Spring_1_Test extends AbstractTestNGSpringContextTests {
    5.   @MockBean
    6.   private Bar bar;
    8.   @Autowired
    9.   private Foo foo;
    11.   @Test
    12.   public void testCheckCodeDuplicate() throws Exception {
    14.     when(bar.getAllCodes()).thenReturn(Collections.singleton("123"));
    15.     assertEquals(foo.checkCodeDuplicate("123"), true);
    17.   }
    19. }

    要注意，如果要启用Spring和Mockito，必须添加这么一行：@TestExecutionListeners(listeners = MockitoTestExecutionListener.class)。

    例子4：配合Spring Test（多层依赖）

    当Bean存在这种依赖关系当时候：LooImpl -> FooImpl -> Bar，我们应该怎么测试呢？

    按照Mock测试的原则，这个时候我们应该mock一个Foo对象，把这个注入到LooImpl对象里，就像例子3里的一样。

    不过如果你不想mock Foo而是想mock Bar的时候，其实做法和前面也差不多，Spring会自动将mock Bar注入到FooImpl中，然后将FooImpl注入到LooImpl中。

    源代码Spring_2_Test:

    1. @ContextConfiguration(classes = { FooImpl.class, LooImpl.class })
    2. @TestExecutionListeners(listeners = MockitoTestExecutionListener.class)
    3. public class Spring_2_Test extends AbstractTestNGSpringContextTests {
    5.   @MockBean
    6.   private Bar bar;
    8.   @Autowired
    9.   private Loo loo;
    11.   @Test
    12.   public void testCheckCodeDuplicate() throws Exception {
    14.     when(bar.getAllCodes()).thenReturn(Collections.singleton("123"));
    15.     assertEquals(loo.checkCodeDuplicate("123"), true);
    17.   }
    19. }

    也就是说，得益于Spring Test Framework，我们能够很方便地对依赖关系中任意层级的任意Bean做mock。

    例子5：配合Spring Boot Test

    源代码Boot_1_Test：

    1. @SpringBoot_1_Test(classes = { FooImpl.class })
    2. @TestExecutionListeners(listeners = MockitoTestExecutionListener.class)
    3. public class Boot_1_Test extends AbstractTestNGSpringContextTests {
    5.   @MockBean
    6.   private Bar bar;
    8.   @Autowired
    9.   private Foo foo;
    11.   @Test
    12.   public void testCheckCodeDuplicate() throws Exception {
    14.     when(bar.getAllCodes()).thenReturn(Collections.singleton("123"));
    15.     assertEquals(foo.checkCodeDuplicate("123"), true);
    17.   }
    19. }

    参考文档

    • Spring Framework Testing
    • Spring Boot Testing
    • Mockito