Mockito使用详解

Mockito

一张思维导图鸟瞰全文

Mockito思维导图.jpg

单元测试

一个单元测试应该有如下特点

  1. 应该是自动化的
  2. 应该可以快速运行
  3. 每个单元测试不应该依赖其它测试的结果和执行顺序,单元测试框架可以按任意的顺序执行每个测试
  4. 每个单元测试不应该依赖数据库,外部文件,或者任何长时间运行的任务。单元测试应该是独立的,不应该依赖于任何外部环境
  5. 单元测试应该在任何时间任何环境都可以任意执行,不该依赖外部环境
  6. 测试应该是有意义的,具有表达性,可以表达出这个测试是测什么,也可以从侧面反推这个被测试的方法的能力
  7. 测试代码应该跟生产代码拥有同等标准要求

Mockito 是什么

为了满足单元测试的隔离性,隔离外部环境,我们需要将外部依赖,通过替身的方式,模拟出一个可以满足我们测试的假对象。

Mockito 就是可以制作假替身,代替外部依赖,模拟我们自定义的返回操作的替身测试框架。

mock替身,很像电影中的替身演员,在某些场景中我们需要替身来处理某些问题。

Mockito 如何使用

1. 设置测试类依托Mockito管理

Mock 需要先设置测试类被 Mockito 管理。有两种方式。

  1. 在测试类上添加注解 @RunWith(MockitoJUnitRunner.class)
  2. 在@Before方法中,调用 MockitoAnnotations.initMocks(this)

上述两种方法使用其一都可,效果一样。

@Before 注解是 Junit 提供的,在每个@Test测试执行前执行一次。

方式1代码示例:

@RunWith(MockitoJUnitRunner.class)
public class MockDemo {
    @Test
    public void testMock() {
        // 处理测试
    }
}

方式2代码示例:

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

2.对类构造替身对象

对类构造替身对象有如下几种方式

  1. 在测试用例中直接使用 Mockito.mock(Class) 方法,生成替身对象
  2. 在测试类中声明需生成替身的依赖类,使用 @Mock 注解。

第二种方式是该测试类中所有单元测试唯一的对象,为了防止每个单元测试 stubbing 的先后顺序对其他单元测试的影响,最好写一个 @After 方法,在该方法中使用 Mockito.reset() 方法清空 stubbing 规则。

@After 注解是 Junit 提供的,在每个@Test测试执行后执行一次。

方法1代码示例:

@RunWith(MockitoJUnitRunner.class)
public class MockDemo {
    @Test
    public void testMock() {
        // 处理测试
        ArrayList mock = mock(ArrayList.class);
    }
}

方法2代码示例:

@RunWith(MockitoJUnitRunner.class)
public class MockDemo {
    @Mock
    private List<String> list;
    
    ... 具体测试 ...
    
    // @After 每个单元测试方法结束后执行,重置 stubbing 
    @After
    public void destory() {
        Mockito.reset(list);
    }
}

Mockito 底层是对被Mock的对象使用 cglib 生成一个代理类。

3. 依赖注入被测试类

Mock 是对被测试类的依赖对象构造替身操作,还需将替身注入到被测试类。注入可以使用 @InjectMocks 注解标识需要被注入的类。依赖的其他类 就用@Mock 注解标识,Mockito 自动将替身注入到被测试类。

代码示例:

@RunWith(MockitoJUnitRunner.class)
public class MockTest {

    @InjectMocks
    private OrderService orderService;

    @Mock
    private OrderMapper orderMapper;
    
}

4. Stubbing

通过 Mock 构造出替身对象后,我们还需要设置替身对象的行为。有点类似录制与播放。比方说设置替身对象调用某方法的返回值。

设置某方法调用的返回值

最常用的一种方式,就是设置某种方法根据某个入参的返回值是什么。或者设置抛出什么异常。

  1. 设置返回对象方式一 when().thenReturn();
  2. 设置返回对象方式二 doReturn().when(对象).对象方法;
  3. 设置抛出异常 when().thenThrow();

设置正常返回代码示例:

@Test
public void testMock() {
    // 处理测试
    list = mock(ArrayList.class);
    // 设置当调用 list.get(0) 的时候,返回 “first value”
    when(list.get(0)).thenReturn("first value");
    assertThat(list.get(0), equalTo("first value"));
}

设置正常返回方式二代码示例:

@Test
public void testMock() {
    // 处理测试
    list = mock(ArrayList.class);
    // 设置当调用 list.get(0) 的时候,返回 “first value”
    Mockito.doReturn("first value").when(list).get(0);
    assertThat(list.get(0), equalTo("first value"));
}

设置抛出异常返回代码示例:

@Test
public void testMock() {
    // 设置当调用 list.get(0) 的时候,抛出异常
    when(list.get(0)).thenThrow(new RuntimeException());
    try {
        list.get(0);
        fail();
    } catch (Exception e) {
        assertThat(e, instanceOf(RuntimeException.class));
    }
}

针对抛出异常的单元测试 Junit 有更优雅的使用方式,ExpectedException。优点就是减少缩进,代码可读性高。

使用方法很简单,具体见如下Junit异常校验代码示例。都是 org.junit 包下。

  1. 声明 ExpectedException ,并添加 @Rule 注解
  2. 在 @Test 测试中,设置 expect 期望抛出什么异常,设置 expect 要在抛出异常的代码之前。

Junit异常校验代码示例:

@RunWith(MockitoJUnitRunner.class)
public class MockDemo {

    @Mock
    private List<String> list;

    @Rule
    public ExpectedException thrown = ExpectedException.none();
    
    @Test
    public void testMock() {
        thrown.expect(RuntimeException.class);
        when(list.get(0)).thenThrow(new RuntimeException());
        list.get(0);
    }
    
}
给Void类型方法设置Stubbing

void 方法,没有返回值,我们也可以设置其什么都不做,也可设置抛出异常。

  1. Void方法什么都不做,执行空逻辑
    Mockito.doNothing().when(对象).对象的方法

  2. Void方法抛出异常

执行空逻辑代码示例:

@Test
public void testMockVoid() {
    // 设置 list 对象 执行 clear 的时候 不执行实际逻辑,执行空逻辑
    Mockito.doNothing().when(list).clear();
    list.clear();
    // 验证 list 对象 对 clear 方法只执行了一次
    Mockito.verify(list, times(1)).clear();
}

抛出异常代码示例:

@Test
public void testMockVoid2() {
    thrown.expect(RuntimeException.class);
    // 设置 list 对象 执行 clear 的时候 不执行实际逻辑,抛出异常
    Mockito.doThrow(new RuntimeException()).when(list).clear();
    list.clear();
}
针对 同一个方法多次调用设置每次的返回值

有时候我们需要设置每一次调用的返回值,比方说某个方法第一次调用返回和第二次调用返回不一样。只要按顺序,只要在 thenReturn() 方法中 用逗号分隔即可,或者执行多次 thenReturn(),链式调用。

逗号分隔代码示例:

@Test
public void testMockReturnMultiple() {
    Mockito.when(list.size()).thenReturn(1, 2, 3, 4);

    assertThat(list.size(), equalTo(1));
    assertThat(list.size(), equalTo(2));
    assertThat(list.size(), equalTo(3));
    assertThat(list.size(), equalTo(4));
}

链式调用代码示例:

@Test
public void testMockReturnMultiple2() {
    Mockito.when(list.size()).thenReturn(1).thenReturn(2).thenReturn(3).thenReturn(4);

    assertThat(list.size(), equalTo(1));
    assertThat(list.size(), equalTo(2));
    assertThat(list.size(), equalTo(3));
    assertThat(list.size(), equalTo(4));
}
替换 方法 为 具体的行为

我们可以给替身对象的方法替换具体的行为,也就是修改其方法实现。

代码示例:

@Test
public void testMockByAnswer() {
    // anyInt 表示任意 int 类型入参,都处理为 answer 中的行为
    Mockito.when(list.get(anyInt())).thenAnswer(invocation -> {
        Integer index = invocation.getArgumentAt(0, Integer.class);
        return String.valueOf(index * 200);
    });

    assertThat(list.get(1), equalTo("200"));
    assertThat(list.get(5), equalTo("1000"));
}
设置 mock 对象依然调用原对象方法

默认mock 的对象的所有方法如果不 stubbing 处理,都是空方法。我们可以指定替身对象依然执行对象本身的实现。

代码示例:

@Test
public void testMockCallRealMethod() {
    // anyInt 表示任意 int 类型入参,都处理为 answer 中的行为
    ArrayList<Object> arrayList = mock(ArrayList.class);
    Mockito.when(arrayList.size()).thenReturn(1).thenCallRealMethod();

    assertThat(arrayList.size(), equalTo(1));
    assertThat(arrayList.size(), equalTo(0));
}

Spying 间谍对象

经过 spy 方法构造的对象,跟 mock 是相反的,spy 构造的方法,如果不设置 stubbing,则依然执行代理的对象的真正方法。使用方式跟 mock 一致。

spying 英文是间谍的意思,说明这不是替身,而是真正对象中一个特殊的对象,大部分方法都跟正常方法一样,只是某些方法有自己的特殊想法。

使用代码示例:

@RunWith(MockitoJUnitRunner.class)
public class SpyDemo {
    @Test
    public void testSpy() {
        // 处理测试
        ArrayList mock = Mockito.spy(ArrayList.class);
    }
}

WILDCARD MATCHERS 通用参数匹配

通用匹配。就是 any()这种任意的。有的时候我们不关注入参的值,只关心返回值,传进去什么都可以,那我们就可以选择使用 wildcard matchers 。

  1. Matchers.any() 匹配任意对象,带着 any 名称的方法 还有 anyInt,anyObject 等都是一样的作用。
  2. Matchers.eq()
    when(list.get(eq(0)) 跟 when(list.get(0) 没区别。提供这个主要是可以在通用参数匹配中,指定特殊的具体value匹配。
  3. Matchers.isA() 表示匹配参数为任意某个类及其子类的对象。

值得注意的事使用通用匹配的话 需要都用通用匹配函数,如果想指定某个参数是特殊值 用eq() 包装一下,示例如下:

@Test
public void testMock() {
    // anyInt 表示任意 int 类型入参,都处理为 answer 中的行为
    ArrayList<Object> arrayList = mock(ArrayList.class);

    // 如下 直接使用会报错,因为后边有 anyObject() 通用匹配
    // Mockito.when(arrayList.set(1, anyObject())).thenReturn("1");
    // 改写成 eq(1) 则可正常运行
    Mockito.when(arrayList.set(eq(1), anyObject())).thenReturn("1");

    assertThat(arrayList.set(1, new Object()), equalTo("1"));
}

Hamcrest Matchers

Hamcrest Matchers 是更优雅的断言,就是上述例子中的 assertThat() 系列方法,不同于 Junit 直接写的 Assert.assertEquals() 大量静态方法,hamcrest matchers 提供了类似函数式编程的可自定义策略的断言方式,允许通过函数的组合搭建出具有表达性的断言。其表达性,可扩展性更强。

assertThat 本质是提供了一个骨架,其实现是调用 Matcher 接口的方法。所以我们可以通过扩展 Matcher接口来扩展各种断言方法。

三个参数的 assertThat() 方法 第一个参数表示 reason 字符串,可以描述一下这个断言。在断言不通过时,会打印该描述。

assertThat 的源码如下,其本质是策略模式和模板方法模式:

public static <T> void assertThat(T actual, Matcher<T> matcher) {
    assertThat("", actual, matcher);
}

public static <T> void assertThat(String reason, T actual,
			Matcher<T> matcher) {
    if (!matcher.matches(actual)) {
        Description description= new StringDescription();
        description.appendText(reason);
        description.appendText("\nExpected: ");
        description.appendDescriptionOf(matcher);
        description.appendText("\n     got: ");
        description.appendValue(actual);
        description.appendText("\n");
        throw new java.lang.AssertionError(description.toString());
    }
}

示例中的类全路径 org.junit.assertThat,org.hamcrest.Matchers

常用Matcher

  1. equalTo() 实际值等于期望对象
  2. not() 不如何如何 可以组装 equalTo() 例如 not(equalTo()) 表示实际值不等于期望对象
  3. is() 跟 equalTo() 一样
  4. greaterThan() 实际值大于期望对象
  5. lessThan() 实际值小于期望对象
  6. either().or() 或关系,满足其一即可
  7. both().and() 且关系,两个条件都得满足
  8. anyOf() 满足其中之一即可,相当于IN
  9. allOf() 所有都满足 相当于一堆 AND
@Test
public void testMatcher() {
    int i = 10;
    assertThat(i, equalTo(10));

    assertThat(i, not(equalTo(20)));

    assertThat(i, is(10));

    assertThat(i, is(not(20)));
    
    assertThat(i, greaterThan(0));

    assertThat(i, lessThan(20));

    assertThat(i, either(equalTo(10)).or(equalTo(20)));

    assertThat(i, both(equalTo(10)).and(equalTo(10)));

    assertThat(i, anyOf(is(10), equalTo(30), equalTo(20)));
    
    assertThat(i, allOf(is(10), equalTo(30), equalTo(20)));
}

自定义 matchers

Hamcrest Matchers 的扩展性强,如果其默认实现的 matcher 无法满足我们的需要,我们可以自行定义 matcher。方法如下。

  1. 创建自定义Matcher类,继承 org.hamcrest.BaseMatcher 类,并声明入参类型的泛型。
  2. 实现 matches() 方法,该方法是assertThat 的回调方法,模板方法,实际的断言逻辑。
  3. 实现 describeTo() 方法,该方法控制断言失败时的文本提示信息。
  4. 自行创建静态工厂方法,用于创建Matcher类,类似于 equalTo() 这种方法。

代码示例如下:

public class StringEqualTo<T extends String> extends BaseMatcher<T> {

    private String value;

    public StringEqualTo(String value) {
        this.value = value;
    }

    // 这个是assertThat 的回调方法,模板方法,实际的断言逻辑
    @Override
    public boolean matches(Object item) {
        return StringUtils.equals(value, (String)item);
    }

    // @Factory 注解标识该静态方法 是 创建 matcher 的工程方法,只是标识,没有别的作用
    @Factory
    public static <T extends String> StringEqualTo<T> stringEqualTo(T t) {
        return new StringEqualTo<>(t);
    }

    // 该方法控制断言失败时的文本提示信息
    @Override
    public void describeTo(Description description) {
        description.appendText("字符串不匹配");
    }

}

使用方法跟其默认实现的一样,示例如下:

@Test
public void testMatcher() {
    String testValue = "hello";
    assertThat(testValue, StringEqualTo.stringEqualTo("hello"));
}

最近很多小伙伴,让我帮忙找一套 Java 学习资料,于是我翻遍了收藏的 1024G 资料,找到一套华为工程师总结的 Java 笔记,可以说是 Java 程序员必备!

整个资料包内容专注 Java 技术,包括 Spring、Spring Boot/Cloud、Dubbo、JVM、集合、多线程、JPA、MyBatis、MySQL、大数据、Nginx、Git、Docker、GitHub、Servlet、JavaWeb、IDEA、Redis、算法、面试题等几乎覆盖了 Java 基础和进阶的方方面面,非常适合初学者入门和进阶者巩固知识!

据说已经有小伙伴通过这套资料,成功的入职了蚂蚁金服、今日头条等大厂。而且,这些资料不是扫描版的,里面的文字都可以直接复制,非常便于我们学习!

分享在这里~ 免积分直接下载~
https://blog.csdn.net/weixin_42116348?type=download
在这里插入图片描述

  • 25
    点赞
  • 53
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
Mockito是一个用于Java的开源测试框架,用于创建和管理模拟对象(mock objects)。它可以帮助我们进行单元测试,特别是在测试依赖对象时非常有用。 在Mockito中,我们可以使用注解来简化模拟对象的创建。例如,使用`@Mock`注解可以创建一个模拟对象,使用`@InjectMocks`注解可以将模拟对象注入到被测试对象中。 Mockito还提供了一些方法来验证模拟对象的交互和行为。例如,使用`verify`方法可以验证方法是否被调用,使用`times`方法可以指定方法被调用的次数,使用`never`方法可以验证方法是否从未被调用。 另外,Mockito还支持设置模拟对象的行为。我们可以使用`when`方法来设置模拟对象方法的返回值,使用`doReturn`方法来设置模拟对象方法的行为。 总之,Mockito是一个强大的测试框架,可以帮助我们进行单元测试,并且使用注解可以简化模拟对象的创建。通过验证和设置模拟对象的行为,我们可以更好地测试我们的代码。 #### 引用[.reference_title] - *1* *2* *3* [【码农教程】手把手教你Mockito使用](https://blog.csdn.net/AI_Green/article/details/129163693)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

宋小黑

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值