• Mockito单元测试

    Mockito

    mockito可以模拟一个真实的对象，如模拟需要连接数据库的对象或者是需要启动spring容器的对象，它并不真正的连接数据库，所以测试时间更快。该模拟出来的对象调用的方法默认情况都是null、0、false。

    使用方式：

    1.在测试类上加上@RunWith(MockitoJUnitRunner.class)注解，如果是springboot应用用@ExtendWith(MockitoExtension.class)注解。

    2.模拟要测试的对象，有多种方式

    • 使用mock方法，如ArrayList list = mock(ArrayList.class);
    • 对象上加@Mock注解，并使用MockitoAnnotations.openMocks(this);注册，这个方法需要在运行测试函数之前被调用，一般放在@Before中
    • @MockBean

    验证verify

    1. @DisplayName("MockitoDemo测试类")
    2. @ExtendWith(MockitoExtension.class)
    3. public class MockitoDemo {
    4.     ArrayList list;
    5. ​
    6.     @Test
    7.     public void mockList() {
    8.         list = mock(ArrayList.class); //mock该对象
    9.         list.get(0);                  //此时任何方法返回值都为null
    10.         verify(list).get(0);          //验证该对象方法是否被执行过。此处执行过，成功
    11.     }
    12. }

    verify()方法是验证该mock对象是否执行过某些方法，如果前面的代码中没有执行过，那会报错，并在控制台上输出 Wanted but not invoked错误。

    和断言是一样的。

    打桩Stub

    让mock对象的方法返回某些特定的值，由自己diy，通过when和then设置。

    1. @Test
    2. public void mockList() {
    3.     list = mock(ArrayList.class);
    4.     //当get(0)时返回hello
    5.     when(list.get(0)).thenReturn("hello");
    6.     //get(1)时方法抛出异常
    7.     when(list.get(1)).thenThrow(new RuntimeException("get any"));
    8.     System.out.println(list.get(0));  //hello
    9.     System.out.println(list.get(1));  //java.lang.RuntimeException: get any
    10. }

    • 默认情况下，没有打桩的函数和函数参数组合返回值没有意义，都是返回null类似的值

    • 通过mock(Foo.class, new YourOwnAnswer()); 可以改变默认情况，没有打桩的程序自己决定返回值

    • 打桩可以被复写(最后的才是最终结果)，但是最好不要

    另一种方式：

    doReturn(1).when(list).get(0);

    连续打桩

    1. list = mock(ArrayList.class);
    2. when(list.get(0)).thenReturn(1).thenReturn(2);
    3. //等同于 when(list.get(0)).thenReturn(1,2);
    4. System.out.println(list.get(0));  //1
    5. System.out.println(list.get(0));  //2
    6. System.out.println(list.get(0));  //后续的任然是2

    • 注意：如果多条打桩动作不在一条语句，那么就是覆盖

    回调方式打桩

    1. list = mock(ArrayList.class);
    2. when(list.get(0)).thenAnswer(new Answer() {
    3.     @Override
    4.     public String answer(InvocationOnMock invocation) throws Throwable {
    5.         Object[] arguments = invocation.getArguments();
    6.         Method method = invocation.getMethod();
    7.         //invocation.callRealMethod();
    8.         Object mock = invocation.getMock();
    9.         return "diy 调用方法";
    10.     }
    11. });
    12. list.get(0);//diy 调用方法
    • 通过thenAnswer方法，参数是自己实现的Answer类，这种方式和Proxy动态代理使用方式类似

    另外还有：doNothing()、doCallRealMethod()

    参数匹配器matchers

    1. @ExtendWith(MockitoExtension.class)
    2. public class MockitoDemo {
    3.     ArrayList list;
    4. ​
    5.     @Test
    6.     public void mockList() {
    7.         list = mock(ArrayList.class);
    8.         //可以使用内置的any()、anyInt()等匹配器，代表所有值、所有整数
    9.         when(list.get(anyInt())).thenReturn("get method");
    10.         //可以使用自定义的参数匹配器
    11.         when(list.contains(argThat(new MyMatcher()))).thenReturn(true);
    12. ​
    13.         System.out.println(list.get(999));          //get method
    14.         System.out.println(list.contains(998));     //true
    15.         System.out.println(list.contains(999));     //false
    16.         //验证是否调用过get函数。这里的anyInt()就是一个参数匹配器。
    17.         verify(list).get(anyInt());
    18.     }
    19. }
    20. //自定义参数匹配器类
    21. class MyMatcher implements ArgumentMatcher {
    22.     @Override
    23.     public boolean matches(Integer v) {
    24.         //表示所有的偶数
    25.         return v % 2 == 0;
    26.     }
    27. }

    注意：如果你使用了参数匹配器, 那么所有参数都要用匹配器。

    1. verify(mock).someMethod(anyInt(), anyString(), eq("third argument"));
    2. // 上述代码是正确的,因为eq()也是一个参数匹配器

    验证续

    验证次数

    verify()方法实则需要指定对应的方法被执行了多少次，默认是1次。

    1. list = mock(ArrayList.class);
    2. list.add(1);
    3. list.add(2);list.add(2);
    4. list.add(3);list.add(3);list.add(3);
    5. ​
    6. verify(list,times(1)).add(1);   //等于verify(list).add(1)
    7. verify(list,times(2)).add(2);   //表示add(2)需要执行正好2次
    8. verify(list,times(3)).add(3); 
    9. ​
    10. verify(list,atLeast(2)).add(3); //最少执行2次
    11. verify(list,atMost(2)).add(1);  //最多执行2次
    12. verify(list,never()).add(999);  //违背执行过

    验证执行顺序

    用于限制mock对象的执行顺序

    1. list = mock(ArrayList.class);
    2. list.get(0);
    3. list.get(1);
    4. //1.为该mock对象创建inorder验证器
    5. InOrder inOrder = inOrder(list);
    6. //2.以你想要的顺序执行验证,顺序一致就验证成功
    7. inOrder.verify(list).get(0);
    8. inOrder.verify(list).get(1);
    9. //Verification in order failure ，验证失败
    10. //inOrder.verify(list).get(1);
    11. //inOrder.verify(list).get(0);

    上例是单个对象方法的执行顺序，也可以限制多个mock对象：

    1. list1 = mock(ArrayList.class);
    2. list2 = mock(ArrayList.class);
    3. list1.get(0);
    4. list2.get(1);
    5. //1.为这两个mock对象创建inorder验证器
    6. InOrder inOrder = inOrder(list1, list2);
    7. //2.验证通过
    8. inOrder.verify(list1).get(0);
    9. inOrder.verify(list2).get(1);

    带超时的验证

    验证的超时时间，验证时间太长了就立即失败

    verify(mock, timeout(500).times(1)).method();

    spy监控

    用于创建spy间谍，去监控真实对象，使用spy对象时会调用真实的方法，但是也可以给spy对象的方法打桩。其实就是真实对象和mock对象的中间形式。

    1. LinkedList linkedList = new LinkedList<>();
    2. LinkedList spy = spy(linkedList);    //创建spy对象
    3. doReturn(100).when(spy).size();  //给某些方法打桩
    4. spy.add("one");
    5. spy.add("two");
    6. System.out.println(spy);                      //[one, two]
    7. System.out.println(spy.size());               //100
    8. verify(spy).add("one");                       //验证通过
    • 注意真实对象还是不变的，变的只是spy对象。
    • 和@Mock类似，还可以用@Spy注解。

    ArgumentCaptor

    前面的验证大部分是验证方法调用这一过程，如果要验证方法调用时使用的参数就需要用ArgumentCaptor。

    1. ArrayList list = mock(ArrayList.class);  
    2. //mock对象调用两次add方法，注意参数
    3. list.add("zhangsan");  
    4. list.add("lisi");
    5. //创建ArgumentCaptor对象，String泛型是需要捕捉的方法的参数类型
    6. ArgumentCaptor argumentCaptor = ArgumentCaptor.forClass(String.class);
    7. //调用verify并且捕捉list.add调用的所有参数。需要注意防止验证失败
    8. verify(list,atLeast(0)).add(argumentCaptor.capture());
    9. //断言，argumentCaptor.getValue()返回最后一次方法调用的参数
    10. Assertions.assertEquals("lisi", argumentCaptor.getValue());
    11. //argumentCaptor.getAllValues()返回所有参数值
    12. Assertions.assertArrayEquals(new Object[]{"zhangsan","lisi"},
    13.         argumentCaptor.getAllValues().toArray());

    使用上面的自定义参数匹配器Argument Matcher也可以实现参数的验证，使用ArgumentCaptor在以下的情况下更合适 :

    • 自定义不能被重用的参数匹配器
    • 你仅需要断言参数值

    打桩时用自定义参数匹配器更好。

    行为驱动开发

    采用given->when->that的顺序编写单元测试

    自动实例化

    @InjectMocks注解和@Mock配合使用，用于有依赖关系的模拟对象

    1. @Data
    2. public class UserInfo {
    3.     private String name;
    4.     private String password;
    5. ​
    6.     public UserInfo(String name, String password) {
    7.         this.name = name;
    8.         this.password = password;
    9.     }
    10. ​
    11. }

    1. @Service
    2. public class UserInfoService {
    3. ​
    4.     @Autowired
    5.     private UserInfoDao userInfoDao;
    6. ​
    7.     public void printInfo() {
    8.         UserInfo userInfo = userInfoDao.select();
    9.         System.out.println(userInfo);
    10.     }
    11. }
    12. ​
    13. public interface UserInfoDao {
    14.     UserInfo select();
    15. }

    如果我要测试这个service，并且不想和数据库有交互，那么可以创建一个UserInfoDao mock对象。被测试类标注为@InjectMocks时，会自动实例化，并且把@Mock或者@Spy标注过的依赖注入进去。

    1. @ExtendWith(MockitoExtension.class)
    2. public class UserInfoServiceTest {
    3. ​
    4.     @InjectMocks
    5.     private UserInfoService userInfoService;
    6. ​
    7.     @Mock
    8.     private UserInfoDao userInfoDao;
    9. ​
    10.     @Test
    11.     public void testPrint() {
    12.         UserInfo userInfo = new UserInfo("admin", "123");
    13. ​
    14.         when(userInfoDao.select()).thenReturn(userInfo);
    15. ​
    16.         userInfoService.printInfo();
    17.     }
    18. }

    springboot测试

    1.controller

    mockito提供了MockMvc类，用于模拟web环境，发送请求到controller。

    • MockMvcBuilders.* 初始化web环境，有两种初始化方式

      • MockMvcBuilders.standaloneSetup(hrjtCcsDealController).build() 针对单个controller进行构造环境
      • MockMvcBuilders.webAppContextSetup(webAppContext).build() 针对整个web环境进行构造
    • MockMvcRequestBuilders.* 构造请求：有get、post……
    • MockMvcResultMatchers.*：搭配ResultActions接口的andExpect()方法来匹配期望的结果。MockMvcResultMatchers.status()方法返回常用的结果判断
    • MockMvcResultHandlers.*：搭配ResultActions接口的andDo()方法对结果进行处理。MockMvcResultHandlers.print()方法返回常用的结果判断

    注意：目前单个类容器还无法识别swagger对参数的校验注解。

    1. @DisplayName("StudentController的测试")
    2. @LunaFrameworkTest(classes = {BizTestConfig.class})
    3. public class StudentControllerTest {
    4.     public MockMvc mockMvc;
    5.     @InjectMocks
    6.     public StudentController studentController;
    7.     @Mock
    8.     public StudentService studentService;
    9. ​
    10.     @Before
    11.     public void before() {
    12.         MockitoAnnotations.openMocks(this);
    13.         //构建MockMvc
    14.         mockMvc = MockMvcBuilders.standaloneSetup(studentController).build();
    15.     }
    16. ​
    17.     @Test
    18.     public void t1() throws Exception {
    19.         StudentPO studentPO = getStudent();
    20.         //任何情况都返回0
    21.         Mockito.when(studentService.create(any())).thenReturn(0);
    22.         //覆盖上一条语句，如果pojo校验正确，返回1
    23.         Mockito.when(studentService.create(argThat(new StudentVerfiy()))).thenReturn(1);
    24.         //发送create请求
    25.         mockMvc.perform(MockMvcRequestBuilders.post("/student/create")
    26.                         //设置request请求的内容
    27.                         .contentType(MediaType.APPLICATION_JSON_UTF8)
    28.                         .content(asJson(studentPO))
    29.                         .accept(MediaType.APPLICATION_JSON_UTF8)
    30.                 )
    31.                 //校验response是否为200，插入成功才是200
    32.                 .andExpect(status().isOk())
    33.                //.andExpect(content().json("xxx"))
    34.                 //打印
    35.                 .andDo(print());
    36. ​
    37.     }
    38. ​
    39.     public StudentPO getStudent() {
    40.         StudentPO studentPO = new StudentPO();
    41.         studentPO.setUrid(UuidUtils.generateUuid());
    42.         studentPO.setAge(20);
    43.         studentPO.setName("马大哈");
    44.         studentPO.setClassid("2");
    45.         studentPO.setSex("男");
    46.         studentPO.setTenantid(20L);
    47.         studentPO.setHeight(169.2f);
    48.         return studentPO;
    49.     }
    50. ​
    51.     public String asJson(Object o) {
    52.         ObjectMapper objectMapper = new ObjectMapper();
    53.         String s;
    54.         try {
    55.             s = objectMapper.writeValueAsString(o);
    56.         } catch (JsonProcessingException e) {
    57.             throw new RuntimeException(e);
    58.         }
    59.         return s;
    60.     }
    61. }
    62. ​
    63. //自定义的校验器
    64. class StudentVerfiy implements ArgumentMatcher {
    65. ​
    66.     @Override
    67.     public boolean matches(StudentPO argument) {
    68.         //写校验逻辑
    69.         if (argument.getAge() > 150 || argument.getAge() < 0)
    70.             return false;
    71.         if (!argument.getSex().equals("男") && !argument.getSex().equals("女"))
    72.             return false;
    73.         return true;
    74.     }
    75. }
     

    • .perform() : 执行一个MockMvcRequestBuilders的请求；MockMvcRequestBuilders有.get()、.post()、.put()、.delete()等请求。
    • .andDo() : 添加一个MockMvcResultHandlers结果处理器，可以用于打印结果输出(MockMvcResultHandlers.print())。
    • .andExpect : 添加MockMvcResultMatchers验证规则，验证执行结果是否正确。
    

     

    2.service层
     

    采用懒加载类的方式，只针对当前使用的service进行bean注入。当前service中涉及到的DaoManager和Client都要mock。
     

    1. @DisplayName("StudentService的测试")
    2. @LunaFrameworkTest(classes = {BizTestConfig.class, AbstractDaoTestConfig.class})
    3. public class StudentServiceTest {
    4.     @InjectMocks //接口需要手动初始化
    5.     private StudentService studentService = new StudentServiceImpl();
    6.     @Mock
    7.     private StudentMapper studentMapper;
    8. ​
    9.     @Test
    10.     public void t1() {
    11.         Mockito.when(studentMapper.insert(any())).thenReturn(0);
    12.         Mockito.when(studentMapper.insert(argThat(new StudentVerfiy()))).thenReturn(1);
    13.         int res = studentService.create(getStudent());
    14.         Assertions.assertEquals(1, res);
    15.     }
    16. ​
    17.     @Before
    18.     public void start() {
    19.         MockitoAnnotations.openMocks(this);
    20.     }
    21. }
     

     

    补充：@ParameterizedTest+@MethodSource获取数据
     

    中文文档：
     

    https://github.com/imsingle/mockito-doc-zh
    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
N-FX2-4 移动链表节点                            
    
网工知识角|华为网络工程师，华为、华三、思科设备三层交换机如何使用三层接口？命令敲起来                            
    
嵌入式Linux裸机开发（一）基础介绍及汇编LED驱动                            
    
2020年全国职业院校技能竞赛网络安全数据包分析capture.pcapng                            
    
LeetCode-解数独（C++）                            
    
云原生之K8S------k8s资源限制及探针检查                            
    
基于springboot+vue 农业资源管理系统java                            
    
Four-dimensional space                            
    
flask返回的数据怎么是转义后的字符串啊                            
    
中文转拼音(带音调)                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/weixin_45902285/article/details/126100137
                
    •