Mockito简单使用

参考文档

官网文档
中文文档

是什么

简介

Mockito 是一款Java类/接口/对象的Mock工具，目前广泛应用于Java应用程序的单元测试中

一句话说明功能：你需要什么就可以mock什么。（比如本地没有Redis但是开发时又需要用到，那么就可以mock一个Redis的功能来隔离对Redis的依赖）

基本流程

creation（创建）---- stubbing（打桩） ---- replay（回放） ---- verification（验证）

1、creation : 创建 【类/接口/对象】 的mock对象

2、stubbing：对方法进行mock

3、replay：调用mock的方法，被mock的方法调用会被Mockito拦截并重定向到stubbing阶段设定的行为

4、verification：基于行为的验证，测试是否正确调用了依赖类，包括：调用了哪些方法；通过怎样的参数;调用了多少次;调用的相对顺序等

怎么用

引入依赖

<!-- mockito 依赖 -->
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-inline</artifactId>
    <version>3.7.7</version>
    <scope>test</scope>
</dependency>

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

使用

简单案例

public class MockitoDemo {
    public int getInt(){
        return 10;
    }
}


@Test
public void test() {
    // 1、创建（创建mock对象）
    MockitoDemo mockitoDemo = mock(MockitoDemo.class);
    // 2、打桩（将 getInt 方法的返回值 mock 成 99）
    when(mockitoDemo.getInt()).thenReturn(99);
    // 3、回放（调用 getInt mock 的方法）
    Assert.assertEquals(99, mockitoDemo.getInt());
    // 4、验证（验证 getInt 方法 mock 后只调用了 1 次）
    verify(mockitoDemo, times(1)).getInt();
}

普通方法

• 有返回值，无参数
• 有返回值，有参数
• 无返回值，无参数
• 无返回值，有参数

public class MockitoDemo {
    // 有返回值，无参数
    public int getInt(){
        return 10;
    }

    // 有返回值，有参数
    public int getIntParameters(int a) {
        return a;
    }

    // 无返回值，无参数
    public void voidTest(){
        int i = 0;
        System.out.println(i);
    }

    // 无返回值，有参数
    public void voidParametersTest(int a){
        int i = a;
        System.out.println(i);
    }
}


@Test
public void test() {
    // 创建 MockitoDemo 对象进行 mock
    MockitoDemo mockitoDemo = mock(MockitoDemo.class);

    // 对方法进行 mock
    // 有返回值，无参数
    when(mockitoDemo.getInt()).thenReturn(9);
    // 有返回值，有参数
    when(mockitoDemo.getIntParameters(anyInt())).thenReturn(99);
    // 无返回值，无参数
    doNothing().when(mockitoDemo).voidTest();
    // 无返回值，有参数
    doNothing().when(mockitoDemo).voidParametersTest(anyInt());

    // 有返回值，无参数
    Assert.assertEquals(9, mockitoDemo.getInt());
    // 有返回值，有参数
    Assert.assertEquals(99, mockitoDemo.getIntParameters(anyInt()));
    // 无返回值，无参数
    mockitoDemo.voidTest();
    // 无返回值，有参数
    mockitoDemo.voidParametersTest(9);
}

静态方法

public class MockitoDemo {
    // 无参数
    public static int getInt(){
        return 10;
    }

    //有参数
    public static int getIntParameters(int a) {
        return a;
    }
}


@Test
public void test() {
    Assert.assertEquals(10, MockitoDemo.getInt());
    Assert.assertEquals(9, MockitoDemo.getIntParameters(9));

    // 创建 MockitoDemo 对象进行 mock
    mockStatic(MockitoDemo.class);

    // 对方法进行 mock
    // 无参数
    when(MockitoDemo.getInt()).thenReturn(199);
    //有参数
    when(MockitoDemo.getIntParameters(anyInt())).thenReturn(299);

    // 无参数
    Assert.assertEquals(199, MockitoDemo.getInt());
    //有参数
    Assert.assertEquals(299, MockitoDemo.getIntParameters(9));
}

spy方法

将对象都不mock，只mock需要mock的方法

public class MockitoDemo {
    public int getInt(){
        return 10;
    }

    public int getIntParameters(int a) {
        return a;
    }
}


@Test
public void test() {
    MockitoDemo demo = new MockitoDemo();
    // 对象都不mock（spy）
    MockitoDemo mockitoDemo = spy(demo);

    // 只mock getInt 方法
    when(mockitoDemo.getInt()).thenReturn(9);

    // mock的方法，走mock逻辑
    Assert.assertEquals(9, mockitoDemo.getInt());
    // 没mock的方法，正常走程序逻辑
    Assert.assertEquals(99, mockitoDemo.getIntParameters(99));
}

verify方法

public class MockitoDemo {
    // 有返回值，无参数
    public int getInt(){
        return 10;
    }
}


@Test
public void test() {
    // 创建 MockitoDemo 对象进行 mock
    MockitoDemo mockitoDemo = mock(MockitoDemo.class);

    // 对方法进行 mock
    when(mockitoDemo.getInt()).thenReturn(9);

    Assert.assertEquals(9, mockitoDemo.getInt());


    // verify 检验
    // 1 次
    verify(mockitoDemo, times(1)).getInt();
    // 一次都没有
    verify(mockitoDemo, never()).getInt();
    // 最多一次
    verify(mockitoDemo, atMostOnce()).getInt();
    // 至少一次
    verify(mockitoDemo, atLeastOnce()).getInt();
    // 至少 2 次
    verify(mockitoDemo, atLeast(2)).getInt();
    // 最多 5 次
    verify(mockitoDemo, atMost(5)).getInt();
}