[Java SE/Junit] 基于Java的单元测试框架Mockito

Mockito 是一个模拟测试框架，主要功能是在单元测试中模拟类/对象的行为。

1 为什么要使用Mockito?

Mock可以理解为创建一个虚假的对象,或者说模拟出一个对象.在测试环境中用来替换掉真实的对象,以达到我们可以

• 验证该对象的某些方法的调用情况,调用了多少次,参数是多少.
• 给这个对象的行为做一个定义,来指定返回结果或指定特定的动作.

2 Mockito数据隔离

根据 JUnit 单测隔离 ，当 Mockito 和 JUnit 配合使用时，也会将非static变量或者非单例隔离开。

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

3 Mock方法

3.1 mock 对象：创建模拟对象

3.1.1 mock 实例对象/实例方法: mock(Class classToMock)

mock方法来自org.mockito.Mock,它标识可以mock一个对象或者是接口

public static <T> mock(Class<T> classToMock);

• 入参：classToMock: 待mock对象的class类
• 返回：mock出来的类的对象(此时对象内依旧无数据)

Random random = Mockito.mock(Random.class);

when(random.nextBoolean()).thenReturn(true);
logger.info("result: {}", random.nextBoolean());//result: true

3.1.2 mock 类对象/静态方法: mockStatic(T.class)

注：QueryFactory#query为静态方法

/**
 * 静态类 T、静态方法的 Mock
 * 1、mock方式: MockedStatic<T> mockClass = mockStatic(T.class); mockClass.when(...).thenReturn(...)
 * 2、静态类/静态方法需在多个测试用例中 mock 时，需使用: `try-with-resources`的方式，以解决此问题"To create a new mock, the existing static mock registration must be deregistered"
 */
try(MockedStatic<QueryFactory> mockedQueryFactory = Mockito.mockStatic(QueryFactory.class)){
	mockedQueryFactory.when( () -> QueryFactory.query(any(), any(), any(), any()) ).thenReturn(result);

	signalNamesMappingCacheService.init();
	try {
		commonSearchBizSevice.executeQuery(requestInfo);//内部将调用 QueryFactory.query(...)
	} catch (Exception e) {
		logger.info("happens a exception: SUCCESS");//内置脚本反射调用失败
	}
}

3.2 Stub 存根 : 为mock对象规定预期的目标执行结果

简述

存根的意思就是给mock对象规定一行的行为,使其按照我们的要求来执行具体的动作。

样例程序

demo1

 //You can mock concrete classes, not just interfaces
 LinkedList mockedList = mock(LinkedList.class);

 //stubbing
 when(mockedList.get(0)).thenReturn("first");
 when(mockedList.get(0)).thenReturn("two");
 when(mockedList.get(1)).thenThrow(new RuntimeException());

 //following prints "two"
 System.out.println(mockedList.get(0));

 //following throws runtime exception
 System.out.println(mockedList.get(1));

 //following prints "null" because get(999) was not stubbed
 System.out.println(mockedList.get(999));

 //Although it is possible to verify a stubbed invocation, usually it's just redundant
 //If your code cares what get(0) returns, then something else breaks (often even before verify() gets executed).
 //If your code doesn't care what get(0) returns, then it should not be stubbed.
 verify(mockedList).get(0);

demo2

@Test
public void test(){
    // 创建Mock对象，参数可以是类或者接口
    List<String> list = mock(List.class);

    // 设置方法的预期返回值
    when(list.get(0)).thenReturn("zuozewei");
    when(list.get(1)).thenThrow(new RuntimeException("test exception"));

    String result = list.get(0);

    // 验证方法调用
    verify(list).get(0);

    //断言，list的第一个元素是否是 "zuozwei"
    Assert.assertEquals(result,"zuozewei");
}

常用方法

mock实例对象的常用方法

• when(mockObject.actionMethod).thenReturn(String t) 设置方法的目标返回值
• when(mockObject.actionMethod).thenThrow(Throwable... throwables) 让方法抛出异常
• when(mockObject.actionMethod).thenAnswer(Answer answer) / then(Answer answer) 自定义方法处理逻辑
• when(mockObject.actionMethod).thenCallRealMethod() 调用 spy 对象的真实方法

mock类对象的常用方法

• mockStaticObject.when(Verification verification).thenReturn(...)

MockedStatic<QueryFactory> mockedQueryFactory = Mockito.mockStatic(QueryFactory.class)
mockedQueryFactory.when( () -> QueryFactory.query(any(), any(), any(), any()) ).thenReturn(result);

3.3 参数匹配：精确匹配与模糊匹配(anyXXX)

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

import java.util.List;

import static org.mockito.Mockito.*;

public class MockitoDemo {

    @Test
    public void test() {
        List mockList = mock(List.class);

        Assert.assertEquals(0, mockList.size());
        Assert.assertEquals(null, mockList.get(0));

        mockList.add("a");  // 调用 mock 对象的写方法，是没有效果的

        Assert.assertEquals(0, mockList.size());      // 没有指定 size() 方法返回值，这里结果是默认值
        Assert.assertEquals(null, mockList.get(0));   // 没有指定 get(0) 返回值，这里结果是默认值

        when(mockList.get(0)).thenReturn("a");          // 指定 get(0)时返回 a

        Assert.assertEquals(0, mockList.size());        // 没有指定 size() 方法返回值，这里结果是默认值
        Assert.assertEquals("a", mockList.get(0));      // 因为上面指定了 get(0) 返回 a，所以这里会返回 a

        Assert.assertEquals(null, mockList.get(1));     // 没有指定 get(1) 返回值，这里结果是默认值

        // 参数匹配：精确匹配
        when(mockStringList.get(0)).thenReturn("a");
        when(mockStringList.get(1)).thenReturn("b");

        Assert.assertEquals("a", mockStringList.get(0));
        Assert.assertEquals("b", mockStringList.get(1));

        // 参数匹配：模糊匹配
        when(mockStringList.get(anyInt())).thenReturn("a");  // 使用 Mockito.anyInt() 匹配所有的 int

        Assert.assertEquals("a", mockStringList.get(0));
        Assert.assertEquals("a", mockStringList.get(1));
    }

    //eq(...)
    @Test
    public void test2(){
        ...
        when(databaseConnectionManager.borrowConnector(eq(DsType2.INFLUXDB), eq(dataSource), any(Integer.class))).thenReturn(connector);
        ...
    }
}

3.4 reset(mockObject) : 重置之前自定义的返回值和异常

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

public class MockitoDemo {
    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));
    }
}

4 Mock 注解

@Mock 注解

@mock快速创建mock的方法,使用

@mock注解需要搭配MockitoAnnotations.openMocks(testClass)方法一起使用.

   public class ArticleManagerTest {

       @Mock
       private ArticleCalculator calculator;
       @Mock
       private ArticleDatabase database;
       @Mock
       private UserProvider userProvider;

       private ArticleManager manager;

       @org.junit.jupiter.api.Test
       void testSomethingInJunit5() {
           // 初始化mock对象
           MockitoAnnotations.openMocks(testClass);
           //Mockito.mock(class);
           Mockito.spy(class);
       }

       // 简化
       // @BeforeEach
       // void setUp() {
       //     MockitoAnnotations.openMocks(this);
       // }

   }

@Spy注解 与 Spy方法

spy 和 mock不同，不同点是：

• spy 的参数是对象实例，mock 的参数是 class。
• 被 spy 的对象，调用其方法时默认会走真实方法。mock 对象不会。

@Spy注解需要搭配MockitoAnnotations.openMocks(testClass)方法一起使用.

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

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

public class MockitoDemo {

    // 测试 spy
    @Test
    public void test_spy() {
        ExampleService spyExampleService = spy(new ExampleService());
        // 默认会走真实方法
        Assert.assertEquals(3, spyExampleService.add(1, 2));
        // 打桩后，不会走了
        when(spyExampleService.add(1, 2)).thenReturn(10);
        Assert.assertEquals(10, spyExampleService.add(1, 2));
        // 但是参数比匹配的调用，依然走真实方法
        Assert.assertEquals(3, spyExampleService.add(2, 1));
    }

    // 测试 mock
    @Test
    public void test_mock() {
        ExampleService mockExampleService = mock(ExampleService.class);
        // 默认返回结果是返回类型int的默认值
        Assert.assertEquals(0, mockExampleService.add(1, 2));
    }
}

spy 对应注解 @Spy，和 @Mock 是一样用的。

import org.junit.Assert;
import org.junit.Test;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;

import static org.mockito.Mockito.*;

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

public class MockitoDemo {
    @Spy
    private ExampleService spyExampleService;

    @Test
    public void test_spy() {
        MockitoAnnotations.openMocks(this);
        Assert.assertEquals(3, spyExampleService.add(1, 2));
        when(spyExampleService.add(1, 2)).thenReturn(10);
        Assert.assertEquals(10, spyExampleService.add(1, 2));
    }
}

@InjectMocks : 注解注入 mock 对象

mockito 会将 @Mock、@Spy 修饰的对象自动注入到 @InjectMocks 修饰的对象中。

注入方式有多种，mockito 会按照下面的顺序尝试注入：

• 构造函数注入
• 设值函数注入（set函数）
• 属性注入

package demo;
import java.util.Random;

public class HttpService {
    public int queryStatus() {
        // 发起网络请求，提取返回结果
        // 这里用随机数模拟结果
        return new Random().nextInt(2);
    }
}

package demo;

public class ExampleService {
    private HttpService httpService;
    public String hello() {
        int status = httpService.queryStatus();
        if (status == 0) {
            return "你好";
        }
        else if (status == 1) {
            return "Hello";
        }
        else {
            return "未知状态";
        }
    }
}

import org.junit.Assert;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import static org.mockito.Mockito.when;

public class ExampleServiceTest {

    @InjectMocks // 将httpService主动注入
    private ExampleService exampleService = new ExampleService();

    @Mock
    private HttpService httpService;

    @Test
    public void test01() {
        MockitoAnnotations.initMocks(this);
        when(httpService.queryStatus()).thenReturn(0);
        Assert.assertEquals("你好", exampleService.hello());
    }
}

验证和断言: verify(...)方法

验证是校验待验证的对象是否发生过某些行为,Mockito中验证的方法是:verify

verify(mock).someMoethod("some arg");
verify(mock,times(100)).someMoethod("some arg");

使用verify验证(Junit的断言机制):

  @Test
  void check() {
    Random random = Mockito.mock(Random.class);
    System.out.println(random.nextInt());
    Mockito.verify(random,Mockito.times(2)).nextInt();
  }

Verify配合times()方法,可以校验某些操作发生的次数

 //using mock
 mockedList.add("once");

 mockedList.add("twice");
 mockedList.add("twice");

 mockedList.add("three times");
 mockedList.add("three times");
 mockedList.add("three times");

 // 默认调用1次
 verify(mockedList).add("once");
 verify(mockedList, times(1)).add("once");

 // 自定义调用多次
 verify(mockedList, times(2)).add("twice");
 verify(mockedList, times(3)).add("three times");

 // 从不调用
 verify(mockedList, never()).add("never happened");

 // atLeast()/atMost()  至少调用 / 之多调用
 verify(mockedList, atMostOnce()).add("once");
 verify(mockedList, atLeastOnce()).add("three times");
 verify(mockedList, atLeast(2)).add("three times");
 verify(mockedList, atMost(5)).add("three times");

 // 超时验证
 verify(mock, timeout(100)).someMethod();
 verify(mock, timeout(100).times(1)).someMethod();

 //只要 someMethod() 在 100 毫秒内被调用 2 次，就会通过
 verify(mock, timeout(100).times(2)).someMethod();

 //someMethod() 至少在 100 毫秒内被调用 2 次，就会通过
 verify(mock, timeout(100).atLeast(2)).someMethod();

5 Mock测试场景

MockMVC 测试 (未亲测)

对于前后端分离的项目而言，无法直接从前端静态代码中测试接口的正确性，因此可以通过MockMVC来模拟HTTP请求。基于RESTful风格的SpringMVC的测试，可以测试完整的Spring MVC流程，即从URL请求到控制器处理，再到视图渲染都可以测试。

初始化MockMvc对象

@Autowired
private WebApplicationContext webApplicationContext;
private MockMvc mockMvc;

//在每个测试方法执行之前都初始化MockMvc对象
@BeforeEach
public void setupMockMvc() {
    mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
}

接口测试

1 controller 层

/**
 * id:\\d+只匹配数字
 * @param id
 * @return
 */
@GetMapping("/user/{id:\\d+}")
public User getUserById(@PathVariable Long id) {

    return userService.getById(id);
}

2 Mockito构建自定义返回结果

userService.getById并没有返回结果，但是我们的测试并不关心userService.getById这个方法是否正常，只是在我们的测试中需要用到这个方法，所以我们可以Mock掉UserService的getById方法，自己定义返回的结果。

@MockBean
private UserService userService;

@Test
void getUserById() throws Exception {

    User user = new User();
    user.setId(1);
    user.setNickname("yunqing");
    //Mock一个结果，当userService调用getById的时候，返回user
    doReturn(user).when(userService).getById(any());

    //perform,执行一个RequestBuilders请求，会自动执行SpringMVC的流程并映射到相应的控制器执行处理
    mockMvc.perform(MockMvcRequestBuilders
            //构造一个get请求
            .get("/user/1")
            //请求类型 json
            .contentType(MediaType.APPLICATION_JSON))
            // 期望的结果状态 200
            .andExpect(MockMvcResultMatchers.status().isOk())
            //添加ResultHandler结果处理器，比如调试时 打印结果(print方法)到控制台
            .andDo(MockMvcResultHandlers.print());
}

3 传参数

@Test
void getUserByUsername() throws Exception {
    // perform : 执行请求 ;
    mockMvc.perform(MockMvcRequestBuilders
            //MockMvcRequestBuilders.get("/url") ： 构造一个get请求
            .get("/user/getUserByName")
            //传参
            .param("username","admin")
            // 请求type : json
            .contentType(MediaType.APPLICATION_JSON))
            // 期望的结果状态 200
            .andExpect(MockMvcResultMatchers.status().isOk());
}

4 期望返回结果集有两个元素

@Test
void getAll() throws Exception {
    User user = new User();
    user.setNickname("yunqing");
    List<User> list = new LinkedList<>();
    list.add(user);
    list.add(user);
    //Mock一个结果，当userService调用list的时候，返回user
    when(userService.list()).thenReturn(list);
    //perform,执行一个RequestBuilders请求，会自动执行SpringMVC的流程并映射到相应的控制器执行处理
    mockMvc.perform(MockMvcRequestBuilders
            //构造一个get请求
            .get("/user/list")
            //请求类型 json
            .contentType(MediaType.APPLICATION_JSON))
            // 期望的结果状态 200
            .andExpect(MockMvcResultMatchers.status().isOk())
            //期望返回的结果集合有两个元素
            .andExpect(MockMvcResultMatchers.jsonPath("$.length()").value(2))
            //添加ResultHandler结果处理器，比如调试时 打印结果(print方法)到控制台
            .andDo(MockMvcResultHandlers.print());
}

5 测试Post请求

@Test
void insert() throws Exception {

    User user = new User();
    user.setNickname("yunqing");
    String jsonResult = JSONObject.toJSONString(user);
    //直接自定义save返回true
    when(userService.save(any())).thenReturn(true);
    // perform : 执行请求 ;
    MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders
            //MockMvcRequestBuilders.post("/url") ： 构造一个post请求
            .post("/user/insert")
            .accept(MediaType.APPLICATION_JSON)
            //传参,因为后端是@RequestBody所以这里直接传json字符串
            .content(jsonResult)
            // 请求type : json
            .contentType(MediaType.APPLICATION_JSON))
            // 期望的结果状态 200
            .andExpect(MockMvcResultMatchers.status().isOk())
            .andDo(MockMvcResultHandlers.print())
            .andReturn();//返回结果

    int statusCode = mvcResult.getResponse().getStatus();
    String result = mvcResult.getResponse().getContentAsString();
    //单个断言
    Assertions.assertEquals(200, statusCode);
    //多个断言，即使出错也会检查所有断言
    assertAll("断言",
            () -> assertEquals(200, statusCode),
            () -> assertTrue("true".equals(result))
    );

• 常用API

//使用jsonPaht验证返回的json中code、message字段的返回值
.andExpect(MockMvcResultMatchers.jsonPath("$.code").value("00000"))
.andExpect(MockMvcResultMatchers.jsonPath("$.message").value("成功"))

//body属性不为空
.andExpect(MockMvcResultMatchers.jsonPath("$.body").isNotEmpty())

// 期望的返回结果集合有2个元素 ， $: 返回结果
.andExpect(MockMvcResultMatchers.jsonPath("$.length()").value(2));

Y 样例集合

Y.1 基于 Mockito 框架的测试类

Y.1.1 Code

import cn.johnny.bd.dataservice.biz.cansignal.service.SignalNamesMappingCacheService;
import cn.johnny.bd.dataservice.biz.dataservice.mapper.IQueryJobMapper;
import cn.johnny.bd.dataservice.common.debug.Print;
import cn.johnny.bd.dataservice.common.sqlTemplate.GlobalInlineVariableNamesEnum;
import cn.johnny.bd.dataservice.model.entity.SignalFieldMapping;
import com.google.common.cache.CacheStats;
import com.google.common.cache.LoadingCache;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.util.AopTestUtils;
import org.springframework.test.util.ReflectionTestUtils;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.mockito.Mockito.*;

//@ExtendWith(MockitoExtension.class)

// MockitoJUnitRunner 为开发者提供了 Mockito 框架使用情况的自动验证，以及自动执行 initMocks()
@RunWith(MockitoJUnitRunner.class) // SpringJUnit4ClassRunner / SpringRunner / MockitoJUnitRunner

public class MockitoTest {
    private static final Logger logger = LoggerFactory.getLogger(MockitoTest.class);

//    @Mock
//    private String canParseMatrixConfigDBName; // [X] 无法 Mock final class

    /**
     * 使用 @Mock 注解封装需要被模拟调用的对象 | @Mock: 创建一个Mock.
     */
    @Mock
    private IQueryJobMapper queryJobMapper;

    @Mock
    private LoadingCache<String, Map<String, SignalFieldMapping>> signalNamesMappingCache;

    /**
     * 使用 @InjetcMock 注解是为了向里面添加 @Mock 注入的对象 | @InjectMocks: 创建一个实例，其余用@Mock（或@Spy）注解创建的mock将被注入到用该实例中。
     */
    @InjectMocks
    private SignalNamesMappingCacheService cacheService;

    @Before
    public void setup(){
        ReflectionTestUtils.setField(cacheService, "canParseMatrixConfigDBName", "johnny_bdp");//final Class(String) 无法成为 Mock 对象。故通过这种 Spring 提供的 ReflectionTestUtils 工具注入该属性
//        ReflectionTestUtils.setField(cacheService, "queryJobMapper", queryJobMapper);
//        ReflectionTestUtils.setField(cacheService, "signalNamesMappingCache", signalNamesMappingCache);
    }

    /**
     * @description
     *  // step1  ready dataset for test stubs(准备测试桩所需的基础数据集)
     *  // step2 setup test stubs(设置测试桩)
     *  // step3 Run the target test class and method (执行测试目标类的目标方法)
     *  // step4 assert , verify and end over(断言、验证与结束)
     */
    @Test
    public void getSignalNamesMappingTestSuccess(){
        // step1  ready dataset for test stubs(准备测试桩所需的基础数据集)
        List<SignalFieldMapping> signalList = new ArrayList<>();
        SignalFieldMapping signalFieldMapping1 = new SignalFieldMapping(1, "bcm_pepsPowerMode", "bcm_peps_power_mode", "bcm_pepsPowerMode", "{\"0\":\"DEFAULT_POWERMODE\",\"1\":\"OFF_POWERMODE\",\"2\":\"ON_POWERMODE\",\"3\":\"RESERVE_POWERMODE\",\"4\":\"RESERVE_POWERMODE1\",\"5\":\"RESERVE_POWERMODE2\",\"6\":\"RESERVE_POWERMODE3\",\"7\":\" INVALID_POWERMODE\"}");
        SignalFieldMapping signalFieldMapping2 = new SignalFieldMapping(2, "bcm_pepsKeyNotInCarInd", "bcm_peps_key_not_in_car_ind", "Keyisnotincarindication.钥匙离开车内提示.", "{\"0\":\"NO_WARNING\",\"1\":\" WARNING\"}");
        signalList.add(signalFieldMapping1);
        signalList.add(signalFieldMapping2);

        CacheStats cacheStats = new CacheStats(1,1,1,1,1,1);

        String globalInlineVariableNamesCode = GlobalInlineVariableNamesEnum.SIGNAL_NAMES_ORIGIN_MAPPING.getCode();

        // step2 setup test stubs(设置测试桩)
        when(queryJobMapper.getSignalFieldMapping("johnny_bdp")).thenReturn(signalList);
        when(signalNamesMappingCache.stats()).thenReturn(cacheStats);

        // step3 Run the target test class and method (执行测试目标类的目标方法)
        cacheService.init();
        Map<String, SignalFieldMapping> signalFieldMappingMap = cacheService.getSignalNamesMapping(globalInlineVariableNamesCode);

        // step4 assert , verify and end over(断言、验证与结束)
        if(!signalFieldMappingMap.isEmpty()){
            logger.debug("signalFieldMappingMap is not empty, content as follows:");
            Print.print(signalFieldMappingMap);
        }

        Assert.assertNotNull(signalFieldMappingMap);
    }

    /**
     * 基本模拟测试1
     * @reference-doc
     *  [1] 走进Java接口测试之Mock（概念篇） - Tencent Cloud - https://cloud.tencent.com/developer/article/1465589
     */
    @Test
    public void mockitoBaseTest(){
        // 创建Mock对象，参数可以是类或者接口
        List<String> list = mock(List.class);

        // 设置方法的预期返回值
        when(list.get(0)).thenReturn("zuozewei");
        when(list.get(1)).thenThrow(new RuntimeException("test exception"));

        String result = list.get(0);
        logger.warn("result:{}", result);// zuozewei

        // 验证方法调用, 若有异常时会直接抛 Exception
        String verifyResult = verify(list).get(0);
        logger.warn("verifyResult:{}", verifyResult);//null

        //断言，list的第一个元素是否是 "zuozwei"
        Assert.assertEquals(result,"zuozewei");
    }

    /**
     * 基本模拟测试2
     */
    @Test
    public void mockBaseTest2(){
        //一旦mock对象被创建了，mock对象会记住所有的交互。然后你就可以选择性的验证感兴趣的交互
        //You can mock concrete classes, not only interfaces
        // 你可以mock具体的类型,不仅只是接口
        //创建 mock 对象，mock 1个 List 接口
//        List mockedList = mock(List.class);
        //若不使用静态导入，则：必须使用 Mockito 调用
//        List mockedList = Mockito.mock(List.class);
        LinkedList mockedList = mock(LinkedList.class);

        //stubbing
        // 测试桩
        when(mockedList.get(0)).thenReturn("first");
        when(mockedList.get(1)).thenThrow(new RuntimeException());

        //following prints "first"
        // 输出 “first”
        System.out.println(mockedList.get(0));

        //following prints "null" because get(999) was not stubbed
        // 因为get(999) 没有打桩，因此输出null
        System.out.println(mockedList.get(999));

        //Although it is possible to verify a stubbed invocation, usually it's just redundant
        //If your code cares what get(0) returns then something else breaks (often before even verify() gets executed).
        //If your code doesn't care what get(0) returns then it should not be stubbed. Not convinced? See here.
        // 验证 get(0) 被调用的次数
        verify(mockedList).get(0);

        // following throws runtime exception
        // 抛出异常 | 因 get(1) 的测试桩是抛出异常
        // System.out.println(mockedList.get(1));
    }

    /**
     * 基本模拟测试3
     */
    @Test
    public void mockBaseTest3(){
        // 生成 mock 对象
        Foo mockFoo = mock(Foo.class);

        // 测试桩
        when(mockFoo.bool(anyString(), anyInt(), any(Object.class))).thenReturn(true);

        // 验证/断言
        Assert.assertTrue(mockFoo.bool("A", 1, "A"));
        Assert.assertTrue(mockFoo.bool("B", 10, new Object()));

        // 测试桩
        when(mockFoo.bool(eq("false"), anyInt(), any(Object.class))).thenReturn(false);
        // 验证/断言
        Assert.assertFalse(mockFoo.bool("false", 10, new Object()));
    }
}

class Foo {
    boolean bool(String str, int i, Object obj) {
        return false;
    }

    int in(boolean b, List<String> strs) {
        return 0;
    }

    int bar(byte[] bytes, String[] s, int i) {
        return 0;
    }
}

Y.1.2 dependency

<!-- org.junit.runner.RunWith;org.junit.Assert;org.junit.Before;org.junit.Test -->
<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<!-- 4.13.1 -->
	<version>${junit.version}</version>
	<scope>test</scope>
</dependency>

<!-- org.slf4j.Logger ; org.slf4j.LoggerFactory; -->
<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>slf4j-api</artifactId>
	<!-- 1.7.25 -->
</dependency>
<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>slf4j-log4j12</artifactId>
	<!-- 1.7.25 -->
</dependency>

<!--
 org.mockito.Mockito; org.mockito.MockedStatic;
 org.mockito.junit.MockitoJUnitRunner;
 org.mockito.InjectMocks; org.mockito.Mock;
 org.mockito.ArgumentMatchers.any; org.mockito.ArgumentMatchers.eq
 -->
<dependency>
	<groupId>org.mockito</groupId>
	<artifactId>mockito-core</artifactId>
	<!-- 3.4.0 -->
	<version>${mockito.version}</version>
	<scope>test</scope>
</dependency>
<dependency>
	<groupId>org.mockito</groupId>
	<artifactId>mockito-inline</artifactId>
	<!-- 3.4.0 -->
	<version>${mockito.version}</version>
</dependency>
<dependency>
	<groupId>org.mockito</groupId>
	<artifactId>mockito-junit-jupiter</artifactId>
	<!-- 3.4.0 -->
	<version>${mockito.version}</version>
	<scope>compile</scope>
	<exclusions>
		<exclusion>
			<artifactId>mockito-core</artifactId>
			<groupId>org.mockito</groupId>
		</exclusion>
	</exclusions>
</dependency>

<dependency>
	<groupId>com.github.jsonzou</groupId>
	<artifactId>jmockdata</artifactId>
	<!-- 4.3.0 -->
	<version>${jmockdata.version}</version>
	<scope>test</scope>
</dependency>

Y.2 基于 spring 框架的测试类

Y.2.1 Code

import cn.johnny.bd.dataservice.TestApplication;
import cn.johnny.bd.dataservice.biz.cansignal.service.SignalNamesMappingCacheService;
import cn.johnny.bd.dataservice.biz.dataservice.mapper.IQueryJobMapper;
import cn.johnny.bd.dataservice.common.debug.Print;
import cn.johnny.bd.dataservice.common.sqlTemplate.GlobalInlineVariableNamesEnum;
import cn.johnny.bd.dataservice.model.entity.SignalFieldMapping;
//import com.github.jsonzou.jmockdata.MockConfig;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
import java.util.Map;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = TestApplication.class)
public class SpringJUnitTest {
    private static final Logger logger = LoggerFactory
            .getLogger(SpringJUnitTest.class);

    @Resource
    private IQueryJobMapper queryJobMapper;

    @Resource
    private SignalNamesMappingCacheService cacheService;

    @Before
    public void init() {

    }

    @Test
    public void test(){
        String globalInlineVariableNamesCode = GlobalInlineVariableNamesEnum.SIGNAL_NAMES_ORIGIN_MAPPING.getCode();
        Map<String, SignalFieldMapping> signalFieldMappingMap = cacheService.getSignalNamesMapping(globalInlineVariableNamesCode);
        Print.print(signalFieldMappingMap);
        Assert.assertNotNull(signalFieldMappingMap);
    }
}

////////////// TestApplication  //////////////

import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan({"cn.johnny"})
public class TestApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(TestApplication.class).web(WebApplicationType.NONE).run(args);
    }

}

Y.2.2 dependency

<!-- org.junit.runner.RunWith;org.junit.Assert;org.junit.Before;org.junit.Test -->
<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<!-- 4.13.1 -->
	<version>${junit.version}</version>
	<scope>test</scope>
</dependency>

<!-- org.slf4j.Logger ; org.slf4j.LoggerFactory; -->
<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>slf4j-api</artifactId>
	<!-- 1.7.25 -->
</dependency>
<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>slf4j-log4j12</artifactId>
	<!-- 1.7.25 -->
</dependency>

<!-- org.springframework.boot.test.context.SpringBootTest -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-test</artifactId>
	<version>2.3.12.RELEASE</version>
	<!-- <scope>compile</scope> -->
</dependency>

<!-- org.springframework.test.context.junit4.SpringJUnit4ClassRunner; org.springframework.test.util.ReflectionTestUtils; -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-test</artifactId>
	<!-- 5.2.15.RELEASE -->
	<scope>test</scope>
</dependency>

K 模拟测试框架小结

mock-server: API/接口测试框架

• MockServer
• mock-server - github

Mokito

• Mockito是mocking框架，它让你用简洁的API做测试。而且Mockito简单易学，它可读性强和验证语法简洁。
• Mockito是GitHub上使用最广泛的Mock框架，并与JUnit结合使用。
• Mockito框架可以创建和配置mock对象。
• 使用Mockito简化了具有外部依赖的类的测试开发。

JMockData

• jmockdata - github
• Jmockdata 随机模拟 java 数据插件 - OSChina

小结

常用的mock框架有:EasyMock、JMock、Mockito、PowerMockito。比较常用的是Mockito。

比较项	EasyMock	JMock	Mockito	PowerMockito
final方法	不支持	不支持	不支持	支持
private方法	不支持	不支持	不支持	支持
静态方法	不支持	不支持	支持	支持
SpringBoot依赖	实现较为复杂	实现较为复杂	默认依赖	基于Mockito扩展
API风格	略复杂	略复杂	简单	简单

X 参考文献

• 基于Java的单元测试框架Mockito - CSDN
• mockito参数匹配_Mockito参数匹配器– any（），eq（） - CSDN
• 单元测试利器-Mockito 中文文档 - CSDN
• 使用Mockito模拟Static静态方法 - CSDN
• Mock工具类静态方法出现registeration must be deregist问题 - CSDN
• Mockito超全用例文档 - CSDN 【推荐】
• 使用JUnit5，Mockito，Hamcrest进行单元测试 - Zhihu 【推荐】
• 走进Java接口测试之Mock（概念篇） - Tengcent Cloud
• Java单元测试之Mock框架 - CSDN
• Guava Cache 缓存数据被移除后的监听器RemovalListener - CSDN