专栏首页房东的猫Mocktio 使用(下)
原创

Mocktio 使用(下)

使用 thenReturn、doReturn设置方法的返回值

thenReturn 用来指定特定函数和参数调用的返回值。thenReturn 中可以指定多个返回值,在调用时返回值依次出现。若调用次数超过返回值的数量,再次调用时返回最后一个返回值。

import org.junit.Assert;
import org.junit.Test;
import static org.mockito.Mockito.*;
import org.mockito.MockitoAnnotations;

import java.util.Random;

public class MockitoTest7 {

    @Test
    public void test() {

        Random mockRandom = mock(Random.class);

        when(mockRandom.nextInt()).thenReturn(1);
        Assert.assertEquals(1, mockRandom.nextInt());
    }

    @Test
    public void test2() {
        Random mockRandom = mock(Random.class);

        when(mockRandom.nextInt()).thenReturn(1, 2, 3);

        Assert.assertEquals(1, mockRandom.nextInt());
        Assert.assertEquals(2, mockRandom.nextInt());
        Assert.assertEquals(3, mockRandom.nextInt());
        Assert.assertEquals(3, mockRandom.nextInt());
        Assert.assertEquals(3, mockRandom.nextInt());
    }

    @Test
    public void test3() {

        MockitoAnnotations.initMocks(this);

        Random random = mock(Random.class);
        doReturn(1).when(random).nextInt();

        Assert.assertEquals(1, random.nextInt());
    }
}

doReturn 的作用和thenReturn相同,但使用方式不同:

使用 thenThrow、doThrow让方法抛出异常

thenThrow 用来让函数调用抛出异常。thenThrow 中可以指定多个异常,在调用时异常依次出现。若调用次数超过异常的数量,再次调用时抛出最后一个异常。

import org.junit.Assert;
import org.junit.Test;
import static org.mockito.Mockito.*;

import java.util.Random;

public class MockitoTest8 {

    @Test
    public void test() {

        Random mockRandom = mock(Random.class);

        when(mockRandom.nextInt()).thenThrow(new RuntimeException("异常"));

        try {
            mockRandom.nextInt();
            Assert.fail();  // 上面会抛出异常,所以不会走到这里
        } catch (Exception ex) {
            System.out.println("RuntimeException");
            Assert.assertTrue(ex instanceof RuntimeException);
            Assert.assertEquals("异常", ex.getMessage());
        }
    }

    @Test
    public void test2() {

        Random mockRandom = mock(Random.class);

        when(mockRandom.nextInt()).thenThrow(new RuntimeException("异常1"), new RuntimeException("异常2"));

        try {
            mockRandom.nextInt();
            Assert.fail();
        } catch (Exception ex) {
            System.out.println("RuntimeException 1");
            Assert.assertTrue(ex instanceof RuntimeException);
            Assert.assertEquals("异常1", ex.getMessage());
        }

        try {
            mockRandom.nextInt();
            Assert.fail();
        } catch (Exception ex) {
            System.out.println("RuntimeException 2");
            Assert.assertTrue(ex instanceof RuntimeException);
            Assert.assertEquals("异常2", ex.getMessage());
        }
    }
}

如果一个对象的方法的返回值是 void,那么不能用 when .. thenThrow 让该方法抛出异常。用 doThrow 可以让返回void的函数抛出异常。

public class MockitoTest10 {

    static class ExampleService {

        public void hello() {
            System.out.println("Hello");
        }
    }

    @Mock
    private ExampleService exampleService;

    @Test
    public void test() {

        MockitoAnnotations.initMocks(this);

        // 这种写法可以达到效果
        doThrow(new RuntimeException("异常")).when(exampleService).hello();

        try {
            exampleService.hello();
            Assert.fail();
        } catch (RuntimeException ex) {
            Assert.assertEquals("异常", ex.getMessage());
        }
    }

    @Test
    public void test2() {

        MockitoAnnotations.initMocks(this);

        Random random = mock(Random.class);

        // 下面这句等同于 when(random.nextInt()).thenThrow(new RuntimeException("异常"));
        doThrow(new RuntimeException("异常")).when(random).nextInt();

        try {
            random.nextInt();
            Assert.fail();
        } catch (RuntimeException ex) {
            Assert.assertEquals("异常", ex.getMessage());
        }
    }
}

使用then、thenAnswer、doAnswer自定义方法处理逻辑

then 和 thenAnswer 的效果是一样的。它们的参数是实现 Answer 接口的对象,在改对象中可以获取调用参数,自定义返回值。

import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.when;

import static org.mockito.Mockito.*;

public class MockitoTest9 {

    static class ExampleService {

        public int add(int a, int b) {
            return a + b;
        }
    }

    @Mock
    private ExampleService exampleService;

    @Test
    public void test() {

        MockitoAnnotations.initMocks(this);

        when(exampleService.add(anyInt(),anyInt())).thenAnswer(new Answer<Integer>() {
            @Override
            public Integer answer(InvocationOnMock invocation) throws Throwable {
                Object[] args = invocation.getArguments();
                // 获取参数
                Integer a = (Integer) args[0];
                Integer b = (Integer) args[1];

                // 根据第1个参数,返回不同的值
                if (a == 1) {
                    return 9;
                }
                if (a == 2) {
                    return 99;
                }
                if (a == 3) {
                    throw new RuntimeException("异常");
                }
                return 999;
            }
        });

        Assert.assertEquals(9, exampleService.add(1, 100));
        Assert.assertEquals(99, exampleService.add(2, 100));

        try {
            exampleService.add(3, 100);
            Assert.fail();
        } catch (RuntimeException ex) {
            Assert.assertEquals("异常", ex.getMessage());
        }
    }

    // doAnswer 的作用和 thenAnswer 相同,但使用方式不同:
    @Test
    public void test2() {

        MockitoAnnotations.initMocks(this);

        Random random = mock(Random.class);
        doAnswer(new Answer() {
            @Override
            public Object answer(InvocationOnMock invocation) throws Throwable {
                return 1;
            }
        }).when(random).nextInt();

        Assert.assertEquals(1, random.nextInt());
    }
}

使用 doNothing 让 void 函数什么都不做

doNothing 用于让 void 函数什么都不做。因为 mock 对象中,void 函数就是什么都不做,所以该方法更适合 spy 对象。

import static org.mockito.Mockito.*;

import org.junit.Test;

public class MockitoTest11 {

    static class ExampleService11 {

        public void hello() {
            System.out.println("Hello");
        }
    }

    @Test
    public void test() {

        ExampleService11 exampleService = spy(new ExampleService11());
        exampleService.hello();  // 会输出 Hello

        // 让 hello 什么都不做
        doNothing().when(exampleService).hello();
        exampleService.hello(); // 什么都不输出
    }
}

使用 reset 重置对象

使用 reset 方法,可以重置之前自定义的返回值和异常。

import org.junit.Test;

import org.junit.Assert;

import static org.mockito.Mockito.*;

public class MockitoTest12 {

    static class ExampleService {

        public int add(int a, int b) {
            return a + b;
        }
    }

    @Test
    public void test() {

        ExampleService exampleService = mock(ExampleService.class);

        // mock 对象方法的默认返回值是返回类型的默认值
        Assert.assertEquals(0, exampleService.add(1, 2));

        // 设置让 add(1,2) 返回 100
        when(exampleService.add(1, 2)).thenReturn(100);
        Assert.assertEquals(100, exampleService.add(1, 2));

        // 重置 mock 对象,add(1,2) 返回 0
        reset(exampleService);
        Assert.assertEquals(0, exampleService.add(1, 2));
    }

    @Test
    public void test2() {

        ExampleService exampleService = spy(new ExampleService());

        // spy 对象方法调用会用真实方法,所以这里返回 3
        Assert.assertEquals(3, exampleService.add(1, 2));

        // 设置让 add(1,2) 返回 100
        when(exampleService.add(1, 2)).thenReturn(100);
        Assert.assertEquals(100, exampleService.add(1, 2));

        // 重置 spy 对象,add(1,2) 返回 3
        reset(exampleService);
        Assert.assertEquals(3, exampleService.add(1, 2));
    }
}

使用 thenCallRealMethod 调用 spy 真实方法

thenCallRealMethod 可以用来重置 spy 对象的特定方法特定参数调用。

import org.junit.Assert;
import org.junit.Test;

import static org.mockito.Mockito.*;

/**
 */
public class MockitoTest13 {

    static class ExampleService {

        public int add(int a, int b) {
            return a+b;
        }
    }

    @Test
    public void test() {

        ExampleService exampleService = spy(new ExampleService());

        // spy 对象方法调用会用真实方法,所以这里返回 3
        Assert.assertEquals(3, exampleService.add(1, 2));

        // 设置让 add(1,2) 返回 100
        when(exampleService.add(1, 2)).thenReturn(100);
        when(exampleService.add(2, 2)).thenReturn(100);
        Assert.assertEquals(100, exampleService.add(1, 2));
        Assert.assertEquals(100, exampleService.add(2, 2));

        // 重置 spy 对象,让 add(1,2) 调用真实方法,返回 3
        when(exampleService.add(1, 2)).thenCallRealMethod();
        Assert.assertEquals(3, exampleService.add(1, 2));

        // add(2, 2) 还是返回 100
        Assert.assertEquals(100, exampleService.add(2, 2));
    }
}

使用 verify 校验是否发生过某些操作

  • 使用 verify 可以校验 mock 对象是否发生过某些操作;
  • 使用 verify 配合 time 方法,可以校验某些操作发生的次数;
import org.junit.Test;

import static org.mockito.Mockito.*;

public class MockitoTest14 {

    static class ExampleService {

        public int add(int a, int b) {
            return a + b;
        }
    }

    @Test
    public void test() {

        ExampleService exampleService = mock(ExampleService.class);

        // 设置让 add(1,2) 返回 100
        when(exampleService.add(1, 2)).thenReturn(100);

        exampleService.add(1, 2);

        // 校验是否调用过 add(1, 2) -> 校验通过
        verify(exampleService).add(1, 2);

        // 校验是否调用过 add(2, 2) -> 校验不通过
        verify(exampleService).add(2, 2);
    }

    @Test
    public void test2() {

        ExampleService exampleService = mock(ExampleService.class);

        // 第1次调用
        exampleService.add(1, 2);

        // 校验是否调用过一次 add(1, 2) -> 校验通过
        verify(exampleService, times(1)).add(1, 2);

        // 第2次调用
        exampleService.add(1, 2);

        // 校验是否调用过两次 add(1, 2) -> 校验通过
        verify(exampleService, times(2)).add(1, 2);
    }
}

使用 mockingDetails 判断是否为 mock对象、spy对象

Mockito 的 mockingDetails 方法会返回 MockingDetails 对象,它的 isMock 方法可以判断对象是否为 mock 对象,isSpy 方法可以判断对象是否为 spy 对象。

public class MockitoTest15 {

    static class ExampleService {

        public int add(int a, int b) {
            return a+b;
        }
    }

    @Test
    public void test() {

        ExampleService exampleService = mock(ExampleService.class);

        // 判断 exampleService 是否为 mock 对象
        System.out.println( mockingDetails(exampleService).isMock() );     // true

        // 判断 exampleService 是否为 spy 对象
        System.out.println( mockingDetails(exampleService).isSpy() );      // false
    }
}

Mockito 测试隔离

使用 @Mock 修饰的 mock 对象在不同的单测中会被隔离开。

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import static org.mockito.Mockito.*;

@RunWith(MockitoJUnitRunner.class)
public class MockitoTest16 {

    static class ExampleService {

        public int add(int a, int b) {
            return a + b;
        }
    }

    @Mock
    private ExampleService exampleService;

    @Test
    public void test01() {
        System.out.println("---call test01---");

        System.out.println("打桩前: " + exampleService.add(1, 2));

        when(exampleService.add(1, 2)).thenReturn(100);

        System.out.println("打桩后: " + exampleService.add(1, 2));
    }

    @Test
    public void test02() {
        System.out.println("---call test02---");

        System.out.println("打桩前: " + exampleService.add(1, 2));

        when(exampleService.add(1, 2)).thenReturn(100);

        System.out.println("打桩后: " + exampleService.add(1, 2));
    }
}

执行结果:
---call test01---
打桩前: 0
打桩后: 100
---call test02---
打桩前: 0
打桩后: 100

test01 先被执行,打桩前调用add(1, 2)的结果是0,打桩后是 100。然后 test02 被执行,打桩前调用add(1, 2)的结果是0,而非 100,这证明了我们上面的说法。

使用 PowerMock 让 Mockito 支持静态方法

PowerMock 是一个增强库,用来增加 Mockito 、EasyMock 等测试库的功能。

Mockito 默认是不支持静态方法,比如我们在 ExampleService 类中定义静态方法 add,尝试给静态方法打桩,会报错。

可以用 Powermock 弥补 Mockito 缺失的静态方法 mock 功能。在 pom 中配置以下依赖:

<dependency>
	<groupId>org.mockito</groupId>
	<artifactId>mockito-core</artifactId>
	<version>2.25.1</version>
</dependency>
<dependency>
	<groupId>org.powermock</groupId>
	<artifactId>powermock-core</artifactId>
	<version>2.0.0</version>
</dependency>
<dependency>
	<groupId>org.powermock</groupId>
	<artifactId>powermock-module-junit4</artifactId>
	<version>2.0.0</version>
</dependency>
<dependency>
	<groupId>org.powermock</groupId>
	<artifactId>powermock-api-mockito2</artifactId>
	<version>2.0.0</version>
</dependency>

PowerMockRunner 支持 Mockito 的 @Mock 等注解。

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

import java.util.Random;

import static org.mockito.Mockito.*;

/**
 * @author Huan Lee
 * @version 1.0
 * @date 10/13/21 4:42 PM
 * @describtion 业精于勤,荒于嬉;行成于思,毁于随。
 */
@RunWith(PowerMockRunner.class)     // 这是必须的
@PrepareForTest(ExampleService17.class)  // 声明要处理 ExampleService17
public class MockitoTest17 {

    @Mock
    private Random random;

    @Test
    public void test() {

        PowerMockito.mockStatic(ExampleService17.class);  // 这也是必须的

        when(ExampleService17.add(1, 2)).thenReturn(100);

        Assert.assertEquals(100, ExampleService17.add(1, 2));
        Assert.assertEquals(0, ExampleService17.add(2, 2));
    }

    @Test
    public void test2() {

        when(random.nextInt()).thenReturn(1);
        Assert.assertEquals(1,  random.nextInt());
    }
}

class ExampleService17 {

    public static int add(int a, int b) {
        return a + b;
    }
}

临时 mock 对象

如果需要临时将一个对象的内部对象替换为 mock 对象,在无法通过set和get处理内部对象的情况下,可以利用反射搞定。

Java JOOR 反射库 是一个很好用的反射库。本文用它进行临时替换。

<dependency>
	<groupId>org.jooq</groupId>
	<artifactId>joor-java-8</artifactId>
	<version>0.9.7</version>
</dependency>
public class HttpService {

    public int queryStatus() {
        // 发起网络请求,提取返回结果
        // 这里直接返回0
        return 0;
    }
}
public class BizService {

    private HttpService httpService = new HttpService();

    public String hello() {
        int status = httpService.queryStatus();
        if (status == 0) {
            return "你好";
        }
        else if (status == 1) {
            return "Hello";
        }
        else {
            return "未知状态";
        }
    }
}
import org.joor.Reflect;
import org.junit.Test;

import static org.mockito.Mockito.*;

public class BizServiceTest {

    private BizService bizService = new BizService();

    @Test
    public void testHello() {

        System.out.println( bizService.hello() );  // 输出'你好'

        // 取出原有的对象
        Object realHttpService = Reflect.on(bizService).get("httpService");

        // 创建 mock 对象,并用它替换掉 bizService 中的 httpService 对象
        HttpService mockHttpService = mock(HttpService.class);
        when(mockHttpService.queryStatus()).thenReturn(1);
        Reflect.on(bizService).set("httpService", mockHttpService);

        System.out.println( bizService.hello() );  // 输出'hello'

        // 再将原先的对象设置回去
        Reflect.on(bizService).set("httpService", realHttpService);
        System.out.println( bizService.hello() );  // 输出'你好'
    }
}

原创声明,本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

登录 后参与评论
0 条评论

相关文章

  • Mocktio 使用(上)

    注意,mock 对象的方法的返回值默认都是返回类型的默认值。例如,返回类型是 int,默认返回值是 0;返回类型是一个类,默认返回值是 null。

    HLee
  • 一向低调的小伙放了个大招,搞定了微服务接口单测依赖问题

    在微服务架构中,服务之间的依赖是很常见的事情。在开发过程中都是并行开发的,前端会依赖后端的接口,后端也有可能会依赖其他后端服务的接口。

    猿天地
  • Linux下tomcat使用

    http://tomcat.apache.org/download-70.cgi这里下载

    用户5166556
  • mac下使用github

          提起github相信大家都不会陌生,在这里就不再赘述了。作为开源代码库以及版本控制系统,使用好了确实会非常受益,再说的势利点,你找工作时给面试官说你...

    猿人谷
  • Ubuntu下使用SVN

    1、首先需要安装SVN。Ubuntu下的SVN安装十分简单,sudo apt-get install subversion,然后根据提示一步一步,就完成了SVN...

    大江小浪
  • Windows 下使用 Memcached

    Memcached 的使用其实就是客户端-服务器模式,所以服务端安装好之后还需要有一个客户端来连接服务端,然后才能进行存取键值对等操作。

    LeoXu
  • python下使用epoll

    因为最近想学习如何用epoll写服务器, 于是找到了一篇介绍的文章. 因为我最近一直看不进技术文章, 于是打算通过翻译来强迫自己学习. 原文在这里:

    py3study
  • Mac 下使用 tmux

    ctrl + b 可以启动命令模式,类似 vim 下的 : 。然后再按 % 可以进行水平切分。

    zucchiniy
  • ubuntu下使用iptables

    Chain FORWARD (policy ACCEPT) target prot opt source destinati...

    dogfei
  • NPM 使用介绍(下)

    package.json 位于模块的目录下,用于定义包的属性。接下来让我们来看下 express 包的 package.json 文件,位于 node_modu...

    陈不成i
  • Nexus操作使用(下)

    Maven 下的setting.xml文件和你自己项目中的pom.xml文件的关系:

    陈不成i
  • Ubuntu下使用svn

    1、首先需要安装svn。Ubuntu下的svn安装十分简单,sudo apt-get install subversion,然后根据提示一步一步,就完成了svn...

    零式的天空
  • windows下使用gcc

    MinGw 是 Minimal GNU on Windows 的缩写,允许在 GNU/Linux 和 Windows 平台生成本地的 Windows 程序而不需...

    meihuasheng
  • python下使用pcl

    各路安装方法参见https://github.com/strawlab/python-pcl,在此仅记录linux下的安装: 1.安装依赖库:

    py3study
  • IDEA下使用AOP

    Charles-LZ
  • python下使用XPath

    槽痞
  • android下使用JNA

    jna在windows和linux下使用都很简单只要导入jna.jar就可以,maven中如下引入就可以了

    用户1148648

扫码关注云+社区

领取腾讯云代金券