Mockito

最新推荐文章于 2024-05-07 22:21:05 发布
最新推荐文章于 2024-05-07 22:21:05 发布
阅读量9.4k 收藏 38
点赞数 7
分类专栏： 测试 文章标签： Mockito
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012894692/article/details/82599100
版权

Mockito是mocking框架，它让你用简洁的API做测试。而且Mockito简单易学，它可读性强和验证语法简洁。
Mockito 是一个针对 Java 的单元测试模拟框架，它与 EasyMock 和 jMock 很相似，都是为了简化单元测试过程中测试上下文 ( 或者称之为测试驱动函数以及桩函数 ) 的搭建而开发的工具
相对于 EasyMock 和 jMock，Mockito 的优点是通过在执行后校验哪些函数已经被调用，消除了对期望行为（expectations）的需要。其它的 mocking 库需要在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码。

Mockito

maven依赖：

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-all</artifactId>
    <version>1.9.5</version>
    <scope>test</scope>
</dependency>
<dependency> 
	<groupId>org.powermock</groupId>
	 <artifactId>powermock-api-mockito2</artifactId> 
	 <version>2.0.0</version> 
	 <scope>test</scope>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
</dependency>

将模拟的对象注入到构造的测试类中

ReflectionTestUtils.setField(Object targetObject, String name, Object value);

@Service
public class BookServiceImpl implements IBookService{

	@Autowired
	private IBookDao bookDao;
}

//将模拟的对象注入到构造的测试类中
ReflectionTestUtils.setField(bookService, "bookDao", bookDao);
常用Mockitod的模拟方法
方法名描述
Mockito.mock(classToMock)模拟对象
Mockito.verify(mock)验证行为是否发生
Mockito.when(methodCall).thenReturn(value1).thenReturn(value2)触发时第一次返回value1，第n次都返回value2
Mockito.doThrow(toBeThrown).when(mock).[method]模拟抛出异常。
Mockito.mock(classToMock,defaultAnswer)使用默认Answer模拟对象
Mockito.when(methodCall).thenReturn(value)参数匹配
Mockito.doReturn(toBeReturned).when(mock).[method]参数匹配（直接执行不判断）
Mockito.when(methodCall).thenAnswer(answer))预期回调接口生成期望值
Mockito.doAnswer(answer).when(methodCall).[method]预期回调接口生成期望值（直接执行不判断）
Mockito.spy(Object)用spy监控真实对象,设置真实对象行为
Mockito.doNothing().when(mock).[method]不做任何返回
Mockito.doCallRealMethod().when(mock).[method] //等价于Mockito.when(mock.[method]).thenCallRealMethod();调用真实的方法
reset(mock)重置mock
实列

验证行为是否发生

//模拟创建一个List对象
List<Integer> mock =  Mockito.mock(List.class);
//调用mock对象的方法
mock.add(1);
mock.clear();
//验证方法是否执行
Mockito.verify(mock).add(1);
Mockito.verify(mock).clear();

多次触发返回不同值

//mock一个Iterator类
Iterator iterator = mock(Iterator.class);
//预设当iterator调用next()时第一次返回hello，第n次都返回world
Mockito.when(iterator.next()).thenReturn("hello").thenReturn("world");
//使用mock的对象
String result = iterator.next() + " " + iterator.next() + " " + iterator.next();
//验证结果
Assert.assertEquals("hello world world",result);

模拟抛出异常

@Test(expected = IOException.class)//期望报Io异常
public void when_thenThrow() throws IOException{
      OutputStream mock = Mockito.mock(OutputStream.class);
      //预设当流关闭时抛出异常
      Mockito.doThrow(new IOException()).when(mock).close();
      mock.close();
  }

使用默认Answer模拟对象
RETURNS_DEEP_STUBS 是创建mock对象时的备选参数之一
以下方法deepstubsTest和deepstubsTest2是等价的

@Test
  public void deepstubsTest(){
      A a=Mockito.mock(A.class,Mockito.RETURNS_DEEP_STUBS);
      Mockito.when(a.getB().getName()).thenReturn("Beijing");
      Assert.assertEquals("Beijing",a.getB().getName());
  }
  
  @Test
  public void deepstubsTest2(){
      A a=Mockito.mock(A.class);
      B b=Mockito.mock(B.class);
      Mockito.when(a.getB()).thenReturn(b);
      Mockito.when(b.getName()).thenReturn("Beijing");
      Assert.assertEquals("Beijing",a.getB().getName());
  }
  class A{
      private B b;
      public B getB(){
          return b;
      }
      public void setB(B b){
          this.b=b;
      }
  }
  class B{
      private String name;
      public String getName(){
          return name;
      }
      public void setName(String name){
          this.name = name;
      }
      public String getSex(Integer sex){
          if(sex==1){
              return "man";
          }else{
              return "woman";
          }
      }
  }

参数匹配

@Test
public void with_arguments(){
    B b = Mockito.mock(B.class);
    //预设根据不同的参数返回不同的结果
    Mockito.when(b.getSex(1)).thenReturn("男");
    Mockito.when(b.getSex(2)).thenReturn("女");
    Assert.assertEquals("男", b.getSex(1));
    Assert.assertEquals("女", b.getSex(2));
    //对于没有预设的情况会返回默认值
    Assert.assertEquals(null, b.getSex(0));
}
class B{
    private String name;
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getSex(Integer sex){
        if(sex==1){
            return "man";
        }else{
            return "woman";
        }
    }
}

匹配任意参数
Mockito.anyInt() 任何int值
Mockito.anyLong() 任何long值
Mockito.anyString() 任何String值
等等

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

使用了参数匹配，那么所有的参数都必须通过matchers来匹配
Mockito继承Matchers，anyInt()等均为Matchers方法
当传入两个参数，其中一个参数采用任意参数时，指定参数需要matchers来对比

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

自定义参数匹配
Mockito.argThat(Matcher matcher) 应用自定义的规则

@Test
public void argumentMatchersTest(){
   //创建mock对象
   List<String> mock = mock(List.class);
   //argThat(Matches<T> matcher)方法用来应用自定义的规则，可以传入任何实现Matcher接口的实现类。
   Mockito.when(mock.addAll(Mockito.argThat(new IsListofTwoElements()))).thenReturn(true);
   Assert.assertTrue(mock.addAll(Arrays.asList("one","two","three")));
}

class IsListofTwoElements extends ArgumentMatcher<List>
{
   public boolean matches(Object list)
   {
       return((List)list).size()==3;
   }
}

预期回调接口生成期望值

@Test
public void answerTest(){
      List mockList = Mockito.mock(List.class);
      //使用方法预期回调接口生成期望值（Answer结构）
      Mockito.when(mockList.get(Mockito.anyInt())).thenAnswer(new CustomAnswer());
      Assert.assertEquals("hello world:0",mockList.get(0));
      Assert.assertEquals("hello world:999",mockList.get(999));
  }
  private class CustomAnswer implements Answer<String> {
      @Override
      public String answer(InvocationOnMock invocation) throws Throwable {
          Object[] args = invocation.getArguments();
          return "hello world:"+args[0];
      }
  }
等价于：(也可使用匿名内部类实现)
@Test
 public void answer_with_callback(){
      //使用Answer来生成我们我们期望的返回
      Mockito.when(mockList.get(Mockito.anyInt())).thenAnswer(new Answer<Object>() {
          @Override
          public Object answer(InvocationOnMock invocation) throws Throwable {
              Object[] args = invocation.getArguments();
              return "hello world:"+args[0];
          }
      });
      Assert.assertEquals("hello world:0",mockList.get(0));
     Assert. assertEquals("hello world:999",mockList.get(999));
  }

预期回调接口生成期望值（直接执行）

@Test
public void testAnswer1(){
List<String> mock = Mockito.mock(List.class);  
      Mockito.doAnswer(new CustomAnswer()).when(mock).get(Mockito.anyInt());  
      Assert.assertEquals("大于三", mock.get(4));
      Assert.assertEquals("小于三", mock.get(2));
}
public class CustomAnswer implements Answer<String> {  
  public String answer(InvocationOnMock invocation) throws Throwable {  
      Object[] args = invocation.getArguments();  
      Integer num = (Integer)args[0];  
      if( num>3 ){  
          return "大于三";  
      } else {  
          return "小于三";   
      }  
  }
}

修改对未预设的调用返回默认期望（指定返回值）

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

用spy监控真实对象,设置真实对象行为

@Test(expected = IndexOutOfBoundsException.class)
    public void spy_on_real_objects(){
        List list = new LinkedList();
        List spy = Mockito.spy(list);
        //下面预设的spy.get(0)会报错，因为会调用真实对象的get(0)，所以会抛出越界异常
        //Mockito.when(spy.get(0)).thenReturn(3);

        //使用doReturn-when可以避免when-thenReturn调用真实对象api
        Mockito.doReturn(999).when(spy).get(999);
        //预设size()期望值
        Mockito.when(spy.size()).thenReturn(100);
        //调用真实对象的api
        spy.add(1);
        spy.add(2);
        Assert.assertEquals(100,spy.size());
        Assert.assertEquals(1,spy.get(0));
        Assert.assertEquals(2,spy.get(1));
        Assert.assertEquals(999,spy.get(999));
    }

不做任何返回

@Test
public void Test() {
    A a = Mockito.mock(A.class);
    //void 方法才能调用doNothing()
    Mockito.doNothing().when(a).setName(Mockito.anyString());
    a.setName("bb");
    Assert.assertEquals("bb",a.getName());
}
class A {
    private String name;
    private void setName(String name){
        this.name = name;
    }
    private String getName(){
        return name;
    }
}

调用真实的方法

@Test
public void Test() {
    A a = Mockito.mock(A.class);
    //void 方法才能调用doNothing()
    Mockito.when(a.getName()).thenReturn("bb");
    Assert.assertEquals("bb",a.getName());
    //等价于Mockito.when(a.getName()).thenCallRealMethod();
    Mockito.doCallRealMethod().when(a).getName();
    Assert.assertEquals("zhangsan",a.getName());
}
class A {
    public String getName(){
        return "zhangsan";
    }
}

重置mock

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

使用@Mock注释

public class MockitoTest {
    @Mock
    private List mockList;
    //必须在基类中添加初始化mock的代码，否则报错mock的对象为NULL
    public MockitoTest(){
        MockitoAnnotations.initMocks(this);
    }
    @Test
    public void AnnoTest() {
            mockList.add(1);
        Mockito.verify(mockList).add(1);
    }
}

指定测试类使用运行器：MockitoJUnitRunner

@RunWith(MockitoJUnitRunner.class)
public class MockitoTest2 {
    @Mock
    private List mockList;

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

参考文档：https://www.cnblogs.com/Ming8006/p/6297333.html

借物小人
关注
  • 7
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Mockito使用记录
denglihongsanren的专栏
01-24 1136
Mockito模拟技巧
SpringBoot 单元测试利器——Mockito
KHOST的博客
02-08 669
Mockito 是一种 Java mock 框架，他主要是用来做 mock 测试的，他可以模拟任何 Spring 管理的 bean、模拟方法的返回值、模拟抛出异常...等，在了解 Mockito 的具体用法之前，得先了解什麽是 mock 测试 1. 什么是 mock 测试？ mock 测试就是在测试过程中，创建一个假的对象，避免你为了测试一个方法，却要自行构建整个 bean 的依赖链 像是以...
SpringBoot 单元测试利器-Mockito
z_ssyy的博客
12-29 2228
mock 测试就是在测试过程中，创建一个假的对象，避免你为了测试一个方法，却要自行构建整个 bean 的依赖链像是以下这张图，类 A 需要调用类 B 和类 C，而类 B 和类 C 又需要调用其他类如 D、E、F 等，假设类 D 是一个外部服务，那就会很难测，因为你的返回结果会直接的受外部服务影响，导致你的单元测试可能今天会过、但明天就过不了了。
单元测试中Mockito的verify方法的使用
ggg123659的博客
05-07 661
在上面的例子中，我们首先创建了一个CommonService的mock对象，然后调用了findConfig方法，并且传入了参数字符串a。随后我们使用Mockito的inOrder方法创建了一个InOrder对象，并使用它来验证findConfig方法findAdminUser方法之前被调用。这时就可以使用verify方法来验证某个外部方法是否被调用，调用次数以及被调用时的参数甚至验证外部方法的调用顺序。//使用verify方法验证findConfig方法是否被调用过，且调用次数为1。//随后调用两个方法。
spring中使用mockito
weixin_33744854的博客
12-08 272
1 mockito介绍和入门 官方：https://github.com/mockito/mockito 入门： 5分钟了解Mockito http://liuzhijun.iteye.com/blog/1512780 Mockito：一个强大的用于 Java 开发的模拟测试框架 http://www.oschina.net/translate/mockito-a-great-mock-f...
spring容器中如何使用Mockito优雅的注入依赖的依赖
lixia0417mul2的博客
01-30 2256
Mockito Spy Mock InjectMocks 正确注入依赖的依赖
mockito
03-28
mockito
Mockito+Junit5测试方法实践
06-12
内容概要：参考Mockito官方API文档，实践框架每个特性。 适合人群：Mockito入门人员以及想全面熟悉Mockito特性的人员，做到了开箱即用。 能学到什么：“Mockito 4.6.0 + Junit 5”的组合编程。 使用建议：使用前安装...
概述 Mockito
11-30
关 于 Mockito 的 概 述
Mockito加junit
最新发布
05-28
Mockito加junit
Java mockito单元测试实现过程解析
09-07
Mockito 是一个流行的 Java 测试框架，它使得单元测试更加容易，特别是当处理依赖于其他组件或服务的代码时。本篇文章将深入解析如何使用 Mockito 实现 Java 单元测试。 首先，让我们看一个简单的例子，有一个名为 ...
Mockito for Spring(PACKT,2015)
04-10
Mockito is a testing framework that creates external dependencies; this process is called mocking. This book will provide you with the skills you need to successfully build and maintain meaningful unit and integration test cases for Spring Framework code. This book starts with a brief introduction to the Spring Framework, including its components and architecture. Packed with real-world examples, the book covers how to make Spring code testable and mock container and external dependencies using Mockito. You then get a walkthrough of the steps that will help you in applying Spring 4 Framework features and advanced Spring testing module features in the real world. By the end of the book, you will be a competent software tester with Spring and Mockito.
Spring Boot单元测试中使用mockito框架mock掉整个RedisTemplate的示例
08-26
今天小编就为大家分享一篇关于Spring Boot单元测试中使用mockito框架mock掉整个RedisTemplate的示例，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
spring集成TestNG与Mockito框架单元测试方法
09-12
spring集成TestNG与Mockito框架单元测试方法
springMVC 整合mockito单元测试学习-附件资源
03-02
springMVC 整合mockito单元测试学习-附件资源
Mockito Cookbook
10-10
Java单元测试核心技能，工作这么多年了，推荐给大家一起学习提高。
Mockito详解
热门推荐
stay hungry ! stay foolish!
04-10 2万+
一、介绍 mockito是众多mock技术中的佼佼者，功能强大，api简洁。 相关文档地址： 【官网地址】 【文档地址】 【中文文档】 二、api （一）Mockito org.mockito.Mockito是mockito提供的核心api，提供了大量的静态方法，用于帮助我们来mock对象，验证行为等等，然后需要注意的是，很多方法都被封装在了MockitoCore类里面，下面对一些常用的方法做一些介绍。 mock：构建一个我们需要的对象；可以mock具体的对象，也可以mock接口。 spy：构建
Mockito详解（二）Mockito中的语法和示例
Vivienne_ChenW的博客
04-15 3028
一、Subbing和Assert
Mockito单元测试详解
RuiKe的博客
10-25 4428
（注意： @RunWith(MockitoJUnitRunner.class) 不能和 @RunWith(SpringRunner.class) 同时使用，而一般都需要 @RunWith(SpringRunner.class) 提供spring容器环境，所以很少用这个注解）SpringBoot默认的Mock框架是Mockito，和junit一样，只需要依赖spring-boot-starter-test就可以了。测试的时候需用调用B服务，但是B服务没写 好，这是可以先Mock一个B服务。
mockito 线程池
12-13
根据提供的引用内容，Mockito本身并不提供线程池的功能，它主要用于编写单元测试。但是，我们可以使用Mockito来模拟线程池的行为，以便在单元测试中测试多线程代码的正确性。以下是一个使用Mockito模拟线程池的例子： ```java import static org.mockito.Mockito.*; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import org.junit.Test; public class ThreadPoolTest { @Test public void testThreadPool() { // 创建一个Mock对象 ExecutorService executor = mock(ExecutorService.class); // 创建一个Runnable对象 Runnable task = mock(Runnable.class); // 提交任务到线程池 executor.submit(task); // 验证任务是否被提交到线程池 verify(executor).submit(task); } } ``` 在这个例子中，我们使用Mockito创建了一个ExecutorService的Mock对象，并使用它来模拟线程池的行为。我们还创建了一个Runnable对象，并将其提交到线程池中。最后，我们使用Mockito的verify()方法验证任务是否被正确提交到线程池中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值