Mockito详细教程

这篇具有很好参考价值的文章主要介绍了Mockito详细教程。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

前言

单元测试(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);

        //调用get(0)时,返回first
        when(mockedList.get(0)).thenReturn("first");
        //调用get(1)时,直接抛出异常
        when(mockedList.get(1)).thenThrow(new RuntimeException());

        //返回first
        System.out.println(mockedList.get(0));
        //抛出异常
        System.out.println(mockedList.get(1));

        //没有存根,则会返回null
        System.out.println(mockedList.get(999));
    }
}

注意点

  • 存根时可以被覆盖的(即对一种情况多次存根的话,以最后一次为准),但是不鼓励这么做,可读性会变差。
  • 一旦存根后,这个函数会一直返回这个值,不管你调用多少次。

返回值为void

即使有些函数返回值为void,也可以使用存根。

//调用clear方法时,抛出异常
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");

        //返回first
        System.out.println(mockedList.get(0));

        //验证是否调用过get函数。这里的anyInt()就是一个参数匹配器。
        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) {
        //do something
    }
}

现在我想验证一个问题,当我发送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");

        //返回first
        System.out.println(mockedList.get(0));
        System.out.println(mockedList.get(0));

        //验证是否被用过get
        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());

甚至支持不指定固定次数

 //一次也不能调用,等于times(0)
 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));

        //获取list的大小
        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);

        //报错 IndexOutOfBoundsException, 因为这个List还是empty
        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

如有错误,欢迎指正!文章来源地址https://www.toymoban.com/news/detail-786298.html

到了这里,关于Mockito详细教程的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 2023单元测试利器Mockito框架详解(超详细~)

    Mockito  是当前最流行的  单元测试   Mock  框架。采用  Mock  框架,我们可以  虚拟  出一个  外部依赖 ,降低测试  组件  之间的  耦合度 ,只注重代码的  流程与结果 ,真正地实现测试目的。 Mock  的中文译为仿制的,模拟的,虚假的。对于测试框架来说,即构造出一

    2024年02月10日
    浏览(39)
  • 一个优质软件测试工程师简历的范文(一定要收藏)

     很多刚转行软件测试的小伙伴是不是不知道怎么写好一份优质的软件测试工程师的简历。今天呢,就给大家分享一下一个优质软件测试工程师简历的范文。记得收藏起来哦。 下面的案例:2-3年的软件测试工程的简历 姓    名:XXX    学历:本科     电    话:186-XXXX-8888

    2024年02月02日
    浏览(69)
  • 在职阿里8年,一个31岁女软件测试工程师的心声

    简单的先说一下,坐标杭州,13届本科毕业,算上年前在阿里巴巴的面试,一共有面试了有6家公司(因为不想请假,因此只是每个晚上去其他公司面试,所以面试的公司比较少) 其中成功的有4家,另外2家失败的原因在于: 1.对于系统知识的了解不够全面,在最后一轮主管面

    2024年02月07日
    浏览(48)
  • 软件工程开发文档写作教程(07)—招投标文件写作规范

    本文原创作者:谷哥的小弟 作者博客地址:http://blog.csdn.net/lfdfhl 本文参考资料:电子工业出版社《软件文档写作教程》 马平,黄冬梅编著 国内的软件项目招投标文件的写作规则并不存在行业标准。许多大型企业的信息化主管在他们的工作中,总是相互传递着一种或多种招标

    2024年02月03日
    浏览(70)
  • 软件工程开发文档写作教程(12)—概要设计书的编制目标

    本文原创作者:谷哥的小弟 作者博客地址:http://blog.csdn.net/lfdfhl 本文参考资料:电子工业出版社《软件文档写作教程》 马平,黄冬梅编著 《概要设计说明书》又称为《系统设计说明书》,编制的目的是说明对软件系统的设计考虑,包括软件系统的基本处理流程、组织结构、

    2024年02月09日
    浏览(42)
  • 软件工程开发文档写作教程(08)—需求分析书的编制目标

    本文原创作者:谷哥的小弟 作者博客地址:http://blog.csdn.net/lfdfhl 本文参考资料:电子工业出版社《软件文档写作教程》 马平,黄冬梅编著 需求分析的基本任务是要准确地定义新系统的目标,为了满足用户需求,回答系统必须“做什么”的问题。获得需求规格说明书。 为了

    2024年02月05日
    浏览(52)
  • 【码农教程】手把手教你Mockito的使用

    1)Mockito:简单轻量级的做mocking测试的框架; 2)mock对象:在调试期间用来作为真实对象的替代品; 3)mock测试:在测试过程中,对那些不容易构建的对象用一个虚拟对象来代替测试的方法就叫mock测试; 4)stub:打桩,就是为mock对象的方法指定返回值(可抛出异常); 5)

    2024年02月05日
    浏览(60)
  • 《软件工程教程》(第2版) 主编:吴迪 马宏茹 丁万宁 第六章课后习题参考答案

    (1)为了提高测试的效率,应该( D )。         A.随机地选取测试数据        B.取一切可能的输入数据作为测试数据        C.在完成编码以后制定软件的测试计划        D.选择发现错误的可能性大的数据作为测试数据 (2)软件测试的目的是( B )。        A.评价

    2024年02月03日
    浏览(96)
  • 《软件工程教程》(第2版) 主编:吴迪 马宏茹 丁万宁 第十二章课后习题参考答案

                                     第十二章   软件项目管理  课后习题参考答案 一、简答题 (1)项目管理的定义是什么?简述软件项目管理的过程。 答:项目管理的定义:项目管理是以项目为对象,通过使用知识、技能、工具和方法来组织、计划、实施并监

    2024年02月02日
    浏览(86)
  • 单元测试(mock) 错误org.mockito.Mockito.framework()Lorg/mockito/MockitoFramework;解析

      如果您觉得有用的话,记得给 博主点个赞,评论,收藏一键三连啊 ,写作不易啊^ _ ^。   而且听说 点赞的人每天的运气都不会太差 ,实在白嫖的话,那欢迎常来啊!!! 01 准备 01::01 安装maven dependency helper插件和maven helper插件 用来分析你的依赖 打开idea 选择 File - Settin

    2023年04月08日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包