使用Mockito进行单元测试实践

使用Mockito进行单元测试实践

Mockito简介以及工作流程

Mockito是一个用于在软件测试中模拟对象的开源框架，使用Mockito很大程度简化了对具有外部依赖项的类的测试开发。

mock的对象就是接口或者类的一个虚拟的实现，他允许自己定义方法的输出。通常是模拟比如和其他系统的交互信息然后再进行测试验证。

mock的流程：

1. mock出来测试类的依赖，自定义输出的结果
2. 执行测试类代码
3. 验证执行的结果是否和预期一致

工程添加Mockito依赖

项目使用的是maven构建，需要添加下面的依赖。我项目中使用的是Junit4。

<dependency>
    <groupId>org.mockitogroupId>
    <artifactId>mockito-inlineartifactId>
    <version>3.3.3version>
dependency>
<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.13.2version>
    <scope>testscope>
dependency>

Mockito的使用

如何mock出一个新的对象

Mockito提供一下几种方式来创建出mock的对象：

• 在Junit5中，使用@ExtendWith(MockitoExtension.class)注解和@Mock注解结合使用来mock对象
• 使用静态的mock()方法直接mock对象
• 使用@Mock注解，这边注意如果要使用@Mock注解的话，需要触发一个初始化的操作，初始化方法是一个静态的方：MockitoAnnotations.initMocks(this)

下面看一个简单的例子：

新建两个类，Database和Service类，Database中提供两个方法，isAvailable和getUniqueId，Service类中依赖Database，提供一个query方法调用databse的isAvailable方法，都只是测试使用。

/**
 * 提供两个方法
 *
 * @since 2022/1/4
 */
public class Database {
    public boolean isAvailable() {
        return false;
    }

    public int getUniqueId() {
        return 22;
    }
}

/**
 * 依赖database
 *
 * @since 2022/1/4
 */
public class Service {
    private final Database database;

    public Service(Database database) {
        this.database = database;
    }

    public boolean query(String query) {
        return database.isAvailable();
    }

    @Override
    public String toString() {
        return "Using database with id: " + database.getUniqueId();
    }
}

使用Mockito来模拟Database对象的单元测试可以按照下面的方式编写：

/**
 * @since 2022/1/4
 */
public class ServiceTest {
    @Mock
    Database database; // 2

    @InjectMocks
    Service service; // 3

    @Before
    public void before() {
        MockitoAnnotations.initMocks(this); // 1
    }

    @Test
    public void testQuery() {
        Assert.assertNotNull(database);
        Mockito.when(database.isAvailable()).thenReturn(true); // 4
        final boolean query = service.query("select * from database"); // 5
        Assert.assertTrue(query); 
    }
}

1. 第一步先触发一个初始化的操作，初始化方法是一个静态的方：MockitoAnnotations.initMocks(this)，写在了Before方法下面。
2. 在第一步的基础之上，可以使用@Mock注解mock出来一个database对象。
3. @InjectMocks注解表示可以通过构造函数、setter方法或者属性注入的方式注入mock的对象，这边service对象提供了一个包含database的构造函数，就可以通过这个注解把mock的database注入进来。
4. 配置mock的对象，设置当isAvailable方法被调用的时候返回true，这些后面会再说明一下。
5. 执行测试的方法，然后用断言判断方法的返回值是否正确。

在mock的对象上面配置方法调用的返回值

上面讲过，Mockito可以自己配置在mock对象上调用方法的返回值。同时，对于没有配置返回值的方法，会返回空值：

• 对于Object类型返回null
• 数字类型返回0
• boolean类型返回false
• …

下面说明一下几个常用的用法：

1. when().thenReturn() 和 when().thenThrow()

   

   使用when(…).thenReturn(…)可以在方法调用的时候，使用预置的参数来返回想要指定的值。

   也可以使用比如anyString或者anyInt这些方法来定义输入的参数，这边就是对于所有的输出都返回指定的值，注意，在mock的时候要么全部使用anyString这种模拟的参数，要么就全部使用真实的参数，不然mock会失败。

   如果想定义多个返回的值，thenReturn也可以支持链式的调用，他会按照指定的顺序一个一个的返回。

   具体案例：

   /**
    * @since 2022/1/21
    */
   public class MockitoWhenTest {
       @Mock
       List<String> mockList;
   
       @Mock
       Comparator<Integer> comparator;
   
       @Before
       public void setUp() {
           MockitoAnnotations.initMocks(this);
       }
   
       // 测试返回指定的值 指定参数
       @Test
       public void testReturnConfiguredValue() {
           Mockito.when(mockList.get(0)).thenReturn("Hello");
           Assert.assertEquals(mockList.get(0), "Hello");
       }
   
       // mock可以指定多个返回值 会按照顺序返回
       @Test
       public void testMoreThanOneReturnValue() {
           Mockito.when(mockList.get(0)).thenReturn("Hello").thenReturn("World");
           Assert.assertEquals(mockList.get(0), "Hello");
           Assert.assertEquals(mockList.get(0), "World");
       }
   
       // 可以指定anyInt anyString等类型 不限定参数的输入 都返回配置的值
       @Test
       public void testReturnValueUseAnyParameter() {
           // 测试用 不要在意功能
           Mockito.when(comparator.compare(9999,9999)).thenReturn(100);
           Assert.assertEquals(comparator.compare(9999,9999), 100);
   
           Mockito.when(comparator.compare(anyInt(), anyInt())).thenReturn(222);
           Assert.assertEquals(comparator.compare(9,232), 222);
       }
   }
   

   使用when().thenReturn()可以用来抛出异常，使用方法很简单，具体案例：

   /**
    * @since 2022/1/21
    */
   public class MockitoThrowTest {
   
       @Test
       public void testThrow() {
           // 这边使用静态的mock方法模拟对象
           Demo demo = Mockito.mock(Demo.class);
           Mockito.when(demo.getAge(anyInt())).thenThrow(new IllegalArgumentException("Warning"));
           IllegalArgumentException exception = Assert.assertThrows(IllegalArgumentException.class, () -> demo.getAge(33));
           Assert.assertEquals(exception.getMessage(), "Warning");
       }
       
       static class Demo {
           public int getAge(int age) {
               return age;
           }
       }
   }
   

2. doReturn().when() 和doThrow().when()

   这两个方法和when().thenReturn()、when().thenThrow()方法一样，都可以模拟mock对象方法的返回，后面这种应该好理解一点。但是对使用@Spy注解模拟的对象来说，doReturn这种方法是有用的。

   对于真实的对象，可以通过@Spy注解来模拟。而且真实的对象的话，会调用真实的方法，如果继续用when().thenReturn()的话，会产生副作用，所以对于这种真实的对象，需要使用doReturn来打桩。emmm，这边我也是根据javadoc翻译的，具体的例子：

   /**
    * @since 2022/1/21
    */
   public class MockitoDoReturnTest {
       @Spy
       List<String> spyList = new LinkedList<>();
   
       @Mock
       List<String> mockList;
   
       @Before
       public void setUp() {
           MockitoAnnotations.initMocks(this);
       }
   
       @Test
       public void doReturnTest() {
           // Mockito.when(spyList.get(0)).thenReturn("Hello");
           // Assert.assertEquals(spyList.get(0), "Hello");
           // 这边会抛出java.lang.IndexOutOfBoundsException: Index: 0, Size: 0 异常
           // spyList其实是一个空列表
           Mockito.doReturn("Hello").when(spyList).get(0);
           Assert.assertEquals(spyList.get(0), "Hello");
   
           Mockito.doReturn("World").when(mockList).get(1);
           Assert.assertEquals(mockList.get(1), "World");
       }
   }
   

Mockito中的行为测试

使用verify()方法可以验证mock的方法是否满足指定的条件，比如可以验证传入的是否是自己指定的参数，该方法调用了几次等等。这种测试被称作行为测试，行为测试不会影响方法调用的接口，但是会检查是否使用了正确的参数调用方法。

示例：

/**
 * @since 2022/1/21
 */
public class MockitoVerifyTest {
    @Mock
    private Dog dog;
    
    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void testVerify() {
        dog.setAge(22);
        dog.setName("Test1");
        dog.setName("Test2");

        // 验证是否设置了age为22
        Mockito.verify(dog).setAge(ArgumentMatchers.eq(22));
        // 验证是否调用了2次setName("Test1")方法
        Mockito.verify(dog, Mockito.times(1)).setName("Test1");

        // 验证是否重来没有调用过指定的方法
        Mockito.verify(dog, Mockito.never()).getAge();
        Mockito.verify(dog, Mockito.never()).setName("Test3");
        // 验证最后一次的mock方法是否是setName("Test2")
        Mockito.verify(dog, Mockito.atLeast(1)).setName("Test2");
    }

    @Data
    static class Dog {
        private int age;
        private String name;
    }
}

使用@InjectMocks进行依赖注入

之前第一个例子说明过@InjectMocks注解的用法，Mockito可以通过构造函数，setter方法或者属性根据类型来注入mock的对象，下面再提供一个示例。

代码示例：

/**
 * @since 2022/1/21
 */
@Setter
public class AccountService {
    // 依赖accountDao以及personDao对象
    private AccountDao accountDao;
    private PersonDao personDao;

    public double getBalance() {
        return accountDao.getBalance();
    }

    public String getName() {
        return personDao.getName();
    }
}

/**
 * @since 2022/1/21
 */
public class AccountDao {
    public double getBalance() {
        return 0;
    }
}

/**
 * @since 2022/1/21
 */
public class PersonDao {
    public String getName() {
        return "";
    }
}

/**
 * @since 2022/1/21
 */
public class MockitoInjectTest {

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
    }

    @Mock
    private AccountDao accountDao;

    @Mock
    private PersonDao personDao;

    @InjectMocks
    private AccountService accountService;

    @Test
    public void testInjectMocks() {
        // mock出accountDao以及personDao对象
        Mockito.when(accountDao.getBalance()).thenReturn(55555.0);
        Mockito.when(personDao.getName()).thenReturn("Jack");

        Assert.assertEquals(accountService.getBalance(), 55555.0, 0);
        Assert.assertEquals(accountService.getName(), "Jack");
    }
}		

对复杂的mock使用Answers

上面讲到了thenReturn，doReturn都是对mock的方法直接指定了返回的值，对于一些复杂的mock的场景，比如说我们想根据指定的参数来计算出返回值，或者对参数做一个回调，可以使用Answers方法。

具体案例：

/**
 * @since 2022/1/22
 */
public class MockitoAnswerTest {

    @Test
    public void doAnswerTest() {
        final Car car = Mockito.mock(Car.class);
        Mockito.doAnswer(invocation -> {
            // 根据参数计算返回值
            final String color = invocation.getArgument(0, String.class);
            final String brand = invocation.getArgument(1, String.class);
            return color + " " + brand;
        }).when(car).getName("red", "BMW");
        Assert.assertEquals(car.getName("red", "BMW"), "red BMW");
    }

    static class Car {
        public String getName(String color, String brand) {
            return "";
        }
    }
}

结语

关于Mockito的使用就总结到这边，Mockito其实还有很多的用法，大家要有兴趣可以自己再找一些资料研究研究。

参考连接：https://www.vogella.com/tutorials/Mockito/article.html

代码地址：https://github.com/yzh19961031/blogDemo/tree/master/mockitoTest