前言
单元测试（UT）
工作一段时间后，才真正意识到代码质量的重要性。虽然囫囵吞枣式地开发，表面上看来速度很快，但是给后续的维护与拓展制造了很多隐患。
作为一个想专业但还不专业的程序员，通过构建覆盖率比较高的单元测试用例，可以比较显著地提高代码质量。如后续需求变更、版本迭代时，重新跑一次单元测试即可校验自己的改动是否正确。
Mockito和单元测试有什么关系？
与集成测试将系统作为一个整体测试不同，单元测试更应该专注于某个类。所以当被测试类与外部类有依赖的时候，尤其是与数据库相关的这种费时且有状态的类，很难做单元测试。但好在可以通过“Mockito”这种仿真框架来模拟这些比较费时的类，从而专注于测试某个类内部的逻辑。
SpringBoot与Mockito
spring-boot-starter-test中已经加入了Mockito依赖，所以我们无需手动引入。
另外要注意一点，在SpringBoot环境下，我们可能会用@SpringBootTest注解。
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@BootstrapWith(SpringBootTestContextBootstrapper.class)
@ExtendWith({SpringExtension.class})
public @interface SpringBootTest {
如果用这个注解，跑单元测试的时候会加载SpringBoot的上下文，初始化Spring容器一次，显得格外的慢，这可能也是很多人放弃在Spring环境下使用单元测试的原因之一。
不过我们可以不用这个Spring环境，单元测试的目的应该是只测试这一个函数的逻辑正确性，某些容器中的相关依赖可以通过Mockito仿真。
所以我们可以直接拓展自MockitoExtendsion，这样跑测试就很快了。
@ExtendWith(MockitoExtension.class)
public class ListMockTest {
}
基本使用
mock与verify
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
public class ListMockTest {
@Test
public void mockList() {
List mockedList = mock(List.class);
mockedList.add("one");
mockedList.clear();
verify(mockedList).add("one");
verify(mockedList).clear();
}
}
mock(List.class)会返回一个List的仿真对象，可以理解为“假对象”，要与后面提到的spy 区分开。
通过Mockito的verify来验证是否调用过List的add方法。
stubbing(存根)
什么是存根
注意：mocking和stubbing背后的理论很庞大。这里的解释只是针对于这个框架而言，比较粗浅。
上面通过mock函数得到了一个代理对象，调用这个对象的函数时，如果有返回值，默认情况下返回值都是null，如果基本类型，默认值是0或者false。
@Test
public void mockList() {
List mockedList = mock(List.class);
System.out.println(mockedList.get(0));
}
控制台输出
null
当测试的单元依赖这个mock对象的返回值时，我们可以通过提前申明这个函数的返回值来测试各种各样的场景。
提前申明的这个过程被称为存根。
@ExtendWith(MockitoExtension.class)
public class ListMockTest {
@Test
public void mockList() {
List mockedList = mock(List.class);
when(mockedList.get(0)).thenReturn("first");
when(mockedList.get(1)).thenThrow(new RuntimeException());
System.out.println(mockedList.get(0));
System.out.println(mockedList.get(1));
System.out.println(mockedList.get(999));
}
}
注意点
- 存根时可以被覆盖的（即对一种情况多次存根的话，以最后一次为准），但是不鼓励这么做，可读性会变差。
- 一旦存根后，这个函数会一直返回这个值，不管你调用多少次。
返回值为void
即使有些函数返回值为void，也可以使用存根。
doThrow(new RuntimeException()).when(mockedList).clear();
mockedList.clear();
连续存根
多次调用，返回不同的值。
@Test
public void mockList() {
List mockedList = mock(List.class);
when(mockedList.get(0)).thenReturn(0).thenReturn(1).thenReturn(2);
System.out.println(mockedList.get(0));
System.out.println(mockedList.get(0));
System.out.println(mockedList.get(0));
}
返回值：
0
1
2
也可以简化为下面的这种写法，效果一样。
when(mockedList.get(0)).thenReturn(0, 1, 2);
设置回调函数
调用某个函数的时候，执行一个回调函数。
@Test
public void mockList() {
List mockedList = mock(List.class);
when(mockedList.get(anyInt())).thenAnswer(new Answer<Object>() {
@Override
public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
System.out.println("哈哈哈，被我逮到了吧");
Object[] arguments = invocationOnMock.getArguments();
System.out.println("参数为:" + Arrays.toString(arguments));
Method method = invocationOnMock.getMethod();
System.out.println("方法名为:" + method.getName());
return "结果由我决定";
}
});
System.out.println(mockedList.get(0));
}
控制台打印：
哈哈哈，被我逮到了吧
参数为:[0]
方法名为:get
结果由我决定
存根函数家族
除了上面出现的doReturn、doThrow、doAnswer外，还有：
doNothing() 啥也不干
doCallRealMethod() 调用真正的方法（不代理）
参数匹配器
基本用法
看完上面的存根，可能会有一个疑问：如果我想监控这个对象有没有被调用get方法，具体参数是什么我并不关心，该咋办。
这个时候就用到了参数匹配器。
@Test
public void mockList() {
List mockedList = mock(List.class);
when(mockedList.get(0)).thenReturn("first");
System.out.println(mockedList.get(0));
verify(mockedList).get(anyInt());
}
处理anyInt()，还有很多的参数匹配器，默认的放在ArgumentMatchers类中。当然，也可以根据需求自定义参数匹配器或者使用hamcrest匹配器。
当一个函数接收多个参数时，如果其中有一个用了参数匹配器，那其他的参数也必须用。
class Student{
public void sleep(int id, String studNo, String name) {
}
}
@Test
public void mockStudent() {
Student student = mock(Student.class);
student.sleep(1, "1", "admin");
verify(student).sleep(anyInt(), anyString(), eq("admin"));
verify(student).sleep(anyInt(), anyString(), eq("admin"));
}
正确的用法是：
@Test
public void mockStudent() {
Student student = mock(Student.class);
student.sleep(1, "1", "admin");
verify(student).sleep(anyInt(), anyString(), eq("admin"));
}
ArgumentCaptor
当我们需要去验证函数外部的一些参数时，就需要用到这个。
以发送邮件为例
定义一个邮件类：
@Data
@NoArgsConstructor
public class Email {
private String to;
private String subject;
private String body;
private EmailStyle emailStyle;
public Email(String to, String subject, String body) {
this.to = to;
this.subject = subject;
this.body = body;
}
}
邮件有以下两种样式
public enum EmailStyle {
HTML,DOC;
}
邮件服务会调用邮件平台发送邮件
public class EmailService {
private DeliveryPlatform deliveryPlatform;
public EmailService(DeliveryPlatform deliveryPlatform) {
this.deliveryPlatform = deliveryPlatform;
}
public void send(String to, String subject, String body, boolean html) {
EmailStyle emailStyle = EmailStyle.DOC;
if(html) {
emailStyle = EmailStyle.HTML;
}
Email email = new Email(to, subject, body);
email.setEmailStyle(emailStyle);
deliveryPlatform.deliver(email);
}
}
邮件平台代码如下：
public class DeliveryPlatform {
public void deliver(Email email) {
}
}
现在我想验证一个问题，当我发送HTML邮件时，deliver这个函数收到的email到底是不是HTML类型的。
这种情况下，就可以通过ArgumentCaptor的方式来解决了。
@ExtendWith(MockitoExtension.class)
public class EmailServiceTest {
@Mock
private DeliveryPlatform deliveryPlatform;
@InjectMocks
private EmailService emailService;
@Captor
private ArgumentCaptor<Email> emailArgumentCaptor;
@Test
public void testHtmlEmail() {
emailService.send("某人", "无题", "无内容", true);
verify(deliveryPlatform).deliver(emailArgumentCaptor.capture());
Email email = emailArgumentCaptor.getValue();
Assertions.assertEquals(EmailStyle.HTML, email.getEmailStyle());
}
}
验证函数被调用的次数
下面的这个测试将不会通过
@Test
public void mockList() {
List mockedList = mock(List.class);
when(mockedList.get(0)).thenReturn("first");
System.out.println(mockedList.get(0));
System.out.println(mockedList.get(0));
verify(mockedList).get(anyInt());
}
报错如下：
org.mockito.exceptions.verification.TooManyActualInvocations:
list.get(<any integer>);
Wanted 1 time:
-> at com.dayrain.mockitodemo.test.ListMockTest.mockList(ListMockTest.java:43)
But was 2 times:
-> at com.dayrain.mockitodemo.test.ListMockTest.mockList(ListMockTest.java:39)
-> at com.dayrain.mockitodemo.test.ListMockTest.mockList(ListMockTest.java:40)
大概意思是，只希望这个函数被调用一次，但实际上被调用了两次。
可能有点懵，不过点进verify方法后就明白了，默认情况下只调用一次；
public static <T> T verify(T mock) {
return MOCKITO_CORE.verify(mock, times(1));
}
所以在调用的verify方法的时候，指定下调用次数即可。
verify(mockedList, times(2)).get(anyInt());
甚至支持不指定固定次数
verify(mockedList, never()).add("never happened");
verify(mockedList, atMostOnce()).add("once");
verify(mockedList, atLeastOnce()).add("three times");
verify(mockedList, atLeast(2)).add("three times");
verify(mockedList, atMost(5)).add("three times");
创建mock对象的另一种方式：@Mock
上述方法都是通过mock方法来构建仿真对象的，其实更简单的方法是通过注解。
@Mock
private List mockedList;
@Test
public void mockList() {
mockedList.add("one");
verify(mockedList).add("one");
}
Spy（间谍）
介绍
上面讲的一些操作都是和Mock出来的对象相关的。通过mock()或者@Mcok注解标注的对象，可以理解为“假对象”。
Spy是针对于“真实存在”的对象。
在重构已有的旧代码时，Spy会比较好用。
@Test
public void spyList() {
List list = new LinkedList();
List spy = spy(list);
when(spy.size()).thenReturn(100);
spy.add("one");
spy.add("two");
System.out.println(spy.get(0));
System.out.println(spy.size());
verify(spy).add("one");
verify(spy).add("two");
}
当使用spy的时候，有一个很容易掉进去的陷进。即spy监听的是真实的对象，在操作真实对象的时候可能会出现越界之类的问题。
@Test
public void spyList() {
List list = new LinkedList();
List spy = spy(list);
when(spy.get(0)).thenReturn("foo");
doReturn("foo").when(spy).get(0);
}
注解
和@Mock类似，还可以用@Spy注解。
BDD(行为驱动开发)
针对比较流行的行为驱动开发，Mockito也提供了对应的支持：
如org.mockito.BDDMockito类中的given//when//then
BDD本文就不做拓展了，后续有时间再做梳理。
超时验证
如果要验证执行是否超时，可以这么做：
verify(student, timeout(1).times(1)).sleep(anyInt(), anyString(), eq("admin"));
自动实例化 @InjectMocks
下面举一个比较常见的例子
已有用户类
@Data
public class UserInfo {
private String name;
private String password;
public UserInfo(String name, String password) {
this.name = name;
this.password = password;
}
}
有对应的服务以及数据存储接口
@Service
public class UserInfoService {
@Autowired
private UserInfoDao userInfoDao;
public void printInfo() {
UserInfo userInfo = userInfoDao.select();
System.out.println(userInfo);
}
}
public interface UserInfoDao {
UserInfo select();
}
如果我要测试这个service，并且不想和数据库有交互，那么可以创建一个UserInfoDao mock对象。
被测试类标注为@InjectMocks时，会自动实例化，并且把@Mock或者@Spy标注过的依赖注入进去。
@ExtendWith(MockitoExtension.class)
public class UserInfoServiceTest {
@InjectMocks
private UserInfoService userInfoService;
@Mock
private UserInfoDao userInfoDao;
@Test
public void testPrint() {
UserInfo userInfo = new UserInfo("admin", "123");
when(userInfoDao.select()).thenReturn(userInfo);
userInfoService.printInfo();
}
}
运行结果为：
UserInfo(name=admin, password=123)
参考
本文大部分内容来自于官网，但不会完全照搬，只整理我认为可能用得到的地方。并且可能会用自己的语言重新组织一下，或者替换部分示例代码，望谅解。
官网地址：https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html
参考博客1：https://semaphoreci.com/community/tutorials/stubbing-and-mocking-with-mockito-2-and-junit
参考博客2：https://www.baeldung.com/mockito-argumentcaptor
如果您对其他语言的模拟也比较感兴趣，例如python，可以学习下面的博客：
https://semaphoreci.com/community/tutorials/getting-started-with-mocking-in-python
如有错误，欢迎指正！
|