mockito简单教程

最新推荐文章于 2024-08-04 16:22:48 发布
最新推荐文章于 2024-08-04 16:22:48 发布
阅读量160 收藏
点赞数
分类专栏： 单测 文章标签： mockito

官网： http://mockito.org

API文档：http://docs.mockito.googlecode.com/hg/org/mockito/Mockito.html

项目源码：https://github.com/mockito/mockito

首先添加maven依赖

 <dependency>
          <groupId>org.mockito</groupId>
          <artifactId>mockito-all</artifactId>
          <version>1.9.5</version>
          <scope>test</scope>
 </dependency>

     
当然mockito需要junit配合使用

<dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
</dependency>


然后为了使代码更简洁，最好在测试类中导入静态资源
import static org.mockito.Mockito.*;
import static org.junit.Assert.*;

下面我们开始使用mockito来做测试
1、验证行为

  

 @Test
    public void verify_behaviour(){
        //模拟创建一个List对象
        List mock = mock(List.class);
        //使用mock的对象
        mock.add(1);
        mock.clear();
        //验证add(1)和clear()行为是否发生
        verify(mock).add(1);
        verify(mock).clear();
    }

2、模拟我们所期望的结果
    

@Test
    public void when_thenReturn(){
        //mock一个Iterator类
        Iterator iterator = mock(Iterator.class);
        //预设当iterator调用next()时第一次返回hello，第n次都返回world
        when(iterator.next()).thenReturn("hello").thenReturn("world");
        //使用mock的对象
        String result = iterator.next() + " " + iterator.next() + " " + iterator.next();
        //验证结果
        assertEquals("hello world world",result);
    }
    @Test(expected = IOException.class)
    public void when_thenThrow() throws IOException {
        OutputStream outputStream = mock(OutputStream.class);
        OutputStreamWriter writer = new OutputStreamWriter(outputStream);
        //预设当流关闭时抛出异常
        doThrow(new IOException()).when(outputStream).close();
        outputStream.close();
    }

3、参数匹配
  

 @Test
    public void with_arguments(){
        Comparable comparable = mock(Comparable.class);
        //预设根据不同的参数返回不同的结果
        when(comparable.compareTo("Test")).thenReturn(1);
        when(comparable.compareTo("Omg")).thenReturn(2);
        assertEquals(1, comparable.compareTo("Test"));
        assertEquals(2, comparable.compareTo("Omg"));
        //对于没有预设的情况会返回默认值
        assertEquals(0, comparable.compareTo("Not stub"));
    }


除了匹配制定参数外，还可以匹配自己想要的任意参数
  

  @Test
    public void with_unspecified_arguments(){
        List list = mock(List.class);
        //匹配任意参数
        when(list.get(anyInt())).thenReturn(1);
        when(list.contains(argThat(new IsValid()))).thenReturn(true);
        assertEquals(1, list.get(1));
        assertEquals(1, list.get(999));
        assertTrue(list.contains(1));
        assertTrue(!list.contains(3));
    }
 
    private class IsValid extends ArgumentMatcher<List>{
        @Override
        public boolean matches(Object o) {
            return o == 1 || o == 2;
        }
    }


需要注意的是如果你使用了参数匹配，那么所有的参数都必须通过matchers来匹配
    

@Test
    public void all_arguments_provided_by_matchers(){
        Comparator comparator = mock(Comparator.class);
        comparator.compare("nihao","hello");
        //如果你使用了参数匹配，那么所有的参数都必须通过matchers来匹配
        verify(comparator).compare(anyString(),eq("hello"));
        //下面的为无效的参数匹配使用
        //verify(comparator).compare(anyString(),"hello");
    }


4、验证确切的调用次数
    

@Test
    public void verifying_number_of_invocations(){
        List list = mock(List.class);
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(3);
        list.add(3);
        list.add(3);
        //验证是否被调用一次，等效于下面的times(1)
        verify(list).add(1);
        verify(list,times(1)).add(1);
        //验证是否被调用2次
        verify(list,times(2)).add(2);
        //验证是否被调用3次
        verify(list,times(3)).add(3);
        //验证是否从未被调用过
        verify(list,never()).add(4);
        //验证至少调用一次
        verify(list,atLeastOnce()).add(1);
        //验证至少调用2次
        verify(list,atLeast(2)).add(2);
        //验证至多调用3次
        verify(list,atMost(3)).add(3);
    }


5、模拟方法体抛出异常
  

 @Test(expected = RuntimeException.class)
    public void doThrow_when(){
        List list = mock(List.class);
        doThrow(new RuntimeException()).when(list).add(1);
        list.add(1);
    }


6、验证执行顺序
    

@Test
    public void verification_in_order(){
        List list = mock(List.class);
        List list2 = mock(List.class);
        list.add(1);
        list2.add("hello");
        list.add(2);
        list2.add("world");
        //将需要排序的mock对象放入InOrder
        InOrder inOrder = inOrder(list,list2);
        //下面的代码不能颠倒顺序，验证执行顺序
        inOrder.verify(list).add(1);
        inOrder.verify(list2).add("hello");
        inOrder.verify(list).add(2);
        inOrder.verify(list2).add("world");
    }


7、确保模拟对象上无互动发生
    

@Test
    public void verify_interaction(){
        List list = mock(List.class);
        List list2 = mock(List.class);
        List list3 = mock(List.class);
        list.add(1);
        verify(list).add(1);
        verify(list,never()).add(2);
        //验证零互动行为
        verifyZeroInteractions(list2,list3);
    }


8、找出冗余的互动(即未被验证到的)
  

 @Test(expected = NoInteractionsWanted.class)
    public void find_redundant_interaction(){
        List list = mock(List.class);
        list.add(1);
        list.add(2);
        verify(list,times(2)).add(anyInt());
        //检查是否有未被验证的互动行为，因为add(1)和add(2)都会被上面的anyInt()验证到，所以下面的代码会通过
        verifyNoMoreInteractions(list);
 
        List list2 = mock(List.class);
        list2.add(1);
        list2.add(2);
        verify(list2).add(1);
        //检查是否有未被验证的互动行为，因为add(2)没有被验证，所以下面的代码会失败抛出异常
        verifyNoMoreInteractions(list2);
    }


9、使用注解来快速模拟
在上面的测试中我们在每个测试方法里都mock了一个List对象，为了避免重复的mock，是测试类更具有可读性，我们可以使用下面的注解方式来快速模拟对象：

    @Mock
    private List mockList;
OK，我们再用注解的mock对象试试
    

@Test
    public void shorthand(){
        mockList.add(1);
        verify(mockList).add(1);
    }


运行这个测试类你会发现报错了，mock的对象为NULL，为此我们必须在基类中添加初始化mock的代码

public class MockitoExample2 {
    @Mock
    private List mockList;
 
    public MockitoExample2(){
        MockitoAnnotations.initMocks(this);
    }
 
    @Test
    public void shorthand(){
        mockList.add(1);
        verify(mockList).add(1);
    }
}


或者使用built-in runner：MockitoJUnitRunner

 

@RunWith(MockitoJUnitRunner.class)
public class MockitoExample2 {
    @Mock
    private List mockList;
 
    @Test
    public void shorthand(){
        mockList.add(1);
        verify(mockList).add(1);
    }
}


更多的注解还有@Captor,@Spy,@InjectMocks

10、连续调用

    

@Test(expected = RuntimeException.class)
    public void consecutive_calls(){
        //模拟连续调用返回期望值，如果分开，则只有最后一个有效
        when(mockList.get(0)).thenReturn(0);
        when(mockList.get(0)).thenReturn(1);
        when(mockList.get(0)).thenReturn(2);
        when(mockList.get(1)).thenReturn(0).thenReturn(1).thenThrow(new RuntimeException());
        assertEquals(2,mockList.get(0));
        assertEquals(2,mockList.get(0));
        assertEquals(0,mockList.get(1));
        assertEquals(1,mockList.get(1));
        //第三次或更多调用都会抛出异常
        mockList.get(1);
    }


11、使用回调生成期望值

  

 @Test
    public void answer_with_callback(){
        //使用Answer来生成我们我们期望的返回
        when(mockList.get(anyInt())).thenAnswer(new Answer<Object>() {
            @Override
            public Object answer(InvocationOnMock invocation) throws Throwable {
                Object[] args = invocation.getArguments();
                return "hello world:"+args[0];
            }
        });
        assertEquals("hello world:0",mockList.get(0));
        assertEquals("world:999",mockList.get(999));
    }


12、监控真实对象
使用spy来监控真实的对象，需要注意的是此时我们需要谨慎的使用when-then语句，而改用do-when语句


    

@Test(expected = IndexOutOfBoundsException.class)
    public void spy_on_real_objects(){
        List list = new LinkedList();
        List spy = spy(list);
        //下面预设的spy.get(0)会报错，因为会调用真实对象的get(0)，所以会抛出越界异常
        //when(spy.get(0)).thenReturn(3);
 
        //使用doReturn-when可以避免when-thenReturn调用真实对象api
        doReturn(999).when(spy).get(999);
        //预设size()期望值
        when(spy.size()).thenReturn(100);
        //调用真实对象的api
        spy.add(1);
        spy.add(2);
        assertEquals(100,spy.size());
        assertEquals(1,spy.get(0));
        assertEquals(2,spy.get(1));
        verify(spy).add(1);
        verify(spy).add(2);
        assertEquals(999,spy.get(999));
        spy.get(2);
    }


13、修改对未预设的调用返回默认期望值

    

@Test
    public void unstubbed_invocations(){
        //mock对象使用Answer来对未预设的调用返回默认期望值
        List mock = mock(List.class,new Answer() {
            @Override
            public Object answer(InvocationOnMock invocation) throws Throwable {
                return 999;
            }
        });
        //下面的get(1)没有预设，通常情况下会返回NULL，但是使用了Answer改变了默认期望值
        assertEquals(999, mock.get(1));
        //下面的size()没有预设，通常情况下会返回0，但是使用了Answer改变了默认期望值
        assertEquals(999,mock.size());
    }


14、捕获参数来进一步断言

       

 @Test
    public void capturing_args(){
        PersonDao personDao = mock(PersonDao.class);
        PersonService personService = new PersonService(personDao);
 
        ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
        personService.update(1,"jack");
        verify(personDao).update(argument.capture());
        assertEquals(1,argument.getValue().getId());
        assertEquals("jack",argument.getValue().getName());
    }
 
     class Person{
        private int id;
        private String name;
 
        Person(int id, String name) {
            this.id = id;
            this.name = name;
        }
 
        public int getId() {
            return id;
        }
 
        public String getName() {
            return name;
        }
    }
 
    interface PersonDao{
        public void update(Person person);
    }
 
    class PersonService{
        private PersonDao personDao;
 
        PersonService(PersonDao personDao) {
            this.personDao = personDao;
        }
 
        public void update(int id,String name){
            personDao.update(new Person(id,name));
        }
    }


15、真实的部分mock

    

@Test
    public void real_partial_mock(){
        //通过spy来调用真实的api
        List list = spy(new ArrayList());
        assertEquals(0,list.size());
        A a  = mock(A.class);
        //通过thenCallRealMethod来调用真实的api
        when(a.doSomething(anyInt())).thenCallRealMethod();
        assertEquals(999,a.doSomething(999));
    }
 
 
    class A{
        public int doSomething(int i){
            return i;
        }
    }


16、重置mock

    

@Test
    public void reset_mock(){
        List list = mock(List.class);
        when(list.size()).thenReturn(10);
        list.add(1);
        assertEquals(10,list.size());
        //重置mock，清除所有的互动和预设
        reset(list);
        assertEquals(0,list.size());
    }


原文：https://blog.csdn.net/sdyy321/article/details/38757135/ 

Sun_22ha
关注
专栏目录
Mockito详细教程
m0_67400972的博客
09-09 428
注意：mocking和stubbing背后的理论很庞大。这里的解释只是针对于这个框架而言，比较粗浅。上面通过mock函数得到了一个代理对象，调用这个对象的函数时，如果有返回值，默认情况下返回值都是null，如果基本类型，默认值是0或者false。@Test}控制台输出null当测试的单元依赖这个mock对象的返回值时，我们可以通过提前申明这个函数的返回值来测试各种各样的场景。提前申明的这个过程被称为存根。@Test//调用get(0)时，返回first。
Mockito基本教程
wuyang528378的专栏
04-16 2379
import static org.junit.Assert.assertEquals; import static org.mockito.Mockito.atLeast; import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.doThrow; import static org.mock
Mockito 入门篇的
Lighthouse
03-06 3236
前言：自动化ui测试已经可以完成基本的测试需求，最主要的还是白盒测试，网上看google官方mvp设计模式，正好配套有unit 测试。顺带看了一下，并分享出来定义：Mockito是一个针对Java的mocking框架。它与EasyMock和jMock很相似，但是通过在执行后校验什么已经被调用，它消除了对期望行为（expectations）的需要。其它的mocking库需要你在执行前记录期望行为（ex
Mockito基础入门
最新发布
qq_45626589的博客
08-04 859
概述Mockito 是一个流行的Java单元测试Mock框架，用于接口和数据模拟。依赖安装</</</</</一旦mock对象被创建了，mock对象会记住所有的交互。然后你就可能选择性的验证你感兴趣的交互。如何做一些测试桩 (Stub)?默认情况下，所有的函数都有返回值。mock函数默认返回的是null，一个空的集合或者一个被对象类型包装的内置类型，例如0、false对应的对象类型为Integer、Boolean；
Mockito教程
weixin_34290390的博客
01-20 225
Mockito教程 2017-01-20 目录 1 Mockito 介绍   1.1 Mockito是什么？  1.2 为什么需要Mock  1.3 Stub和Mock异同  1.4 Mockito资源  1.5 使用场景2 使用Mockito   2.1 验证行为  2.2 模拟我们所期望的结果  2.3 RETURNS_SMART_NULLS和RETURNS_DEEP_STUBS  2....
mockito 使用教程以及示例
05-25
Mockito 是一个 Java 测试框架，用于模拟（mock）依赖项并使测试代码更简单和可读。它可以帮助您快速创建假的对象和模拟方法的行为。以下是 Mockito 的使用教程和示例。 ### 安装 Mockito 在使用 Mockito 之前，您...
Mockito简单实用教程 - 第一部分mock
AE793557590的博客
03-09 1644
Mockito简单实用教程 - 第一部分环境介绍依赖内容1. 检验方法是否有被调用2. 指定mock方法的返回值3. 验证指定次数4. 验证异常5. 校验执行顺序6. 校验形参7. 参数匹配新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建...
mockito-all-1.9.5 jar包
11-06
最新比较稳定的版本
java的mockito框架教程有吗，发一份
09-19
以下是一份简短的Mockito教程，涵盖了Mockito的一些基本功能： 1. 安装Mockito：在您的项目中使用Mockito，您需要将其添加为依赖项。在Maven项目中，您可以通过将以下依赖项添加到您的pom.xml文件中来安装Mockito：...
Mockito 教程
Andy's Blog
03-15 866
    说在前面的话     现在软件公司里面(我待过的4个公司)大家对编写测试用例都很厌倦，认为这是没有必要的，出现bug很正常。我认为如果这样下去这个项目就不会好，因为我们都接触过一些别人移交给我们的代码，甚至是自己原来写过的代码，时间久了根本没有办法去重构，因为我们都很清楚项目已经上线，如果现在改动代码很容易照成一堆bug的出现，那么就完蛋了，所以后期就会出现打补丁方式的修复bug。但是如果...
Mockito测试实例
快快乐乐，天天开心
04-22 899
Mockito是现在java领域中,用java语言编写的测试代码保持最简洁的一个mock框架(不与groovy等比较)。相比easymock,jmock,编写出来的代码更加容易阅读。无需录制mock方法调用就返回默认值是很大一个优势。   以下为实际的精简测试用例使用，相比较其它mock框架，更加容易阅读。更加符合DSL。   Java代码  
Mockito单元测试学习笔记（1）：Mockito简介
sinat_38393872的博客
06-03 2699
本文是自己学习的一个总结 1、什么是单元测试 我自己的理解是，单元测试就是面向函数的一个测试。这种测试只是针对函数内的逻辑进行测试。如果这个函数依赖了外界，那么单元测试是应该要屏蔽掉外界的影响的。 比如web开发中，service层中有一个方法用来用来插入数据。 public class Service implements ServiceImpl { /** * 这就是service中一个普通的方法，但它在执行过程中会依赖外部资源。 */ @Override public void in.
单元测试Mock
qq_35932990的博客
01-19 1358
有些数据mock需要额外的工具进行（比如需要mock静态、final方法），如Mockito.MockedStatic，PowerMock等等，文档下面的例子全部都是使用PowerMock进行。
Mockito单元测试
qq_42772400的博客
12-20 810
Mockito单元测试
Mockito入门教程：单元测试必备
Mockito是一款在Java单元测试中广泛使用的模拟框架，它使得测试变得更加简单和高效。Mockito允许开发者创建模拟对象，这些模拟对象可以在测试过程中代替真实的依赖，以便隔离测试代码并确保每个单元的正确性。通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值