devbox
Li_阴宅
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Mock测试详细教程入门这一篇就够了_单元测试mock

作者：Li_阴宅 | 2024-07-28 21:32:15

赞

踩

单元测试mock

1、什么是mock测试

1.png

Mock测试就是在测试活动中，对于某些不容易构造或者不容易获取的比较复杂的数据/场景，用一个虚拟的对象(Mock对象)来创建用于测试的测试方法。

2、为什么要进行Mock测试

Mock是为了解决不同的单元之间由于耦合而难于开发、测试的问题。所以，Mock既能出现在单元测试中，也会出现在集成测试、系统测试过程中。

Mock最大的功能是帮你把单元测试的耦合分解开，如果你的代码对另一个类或者接口有依赖，它能够帮你模拟这些依赖，并帮你验证所调用的依赖的行为。

3、Mock适用场景

1、需要将当前被测单元和其依赖模块独立开来，构造一个独立的测试环境，不关注被测单元的依赖对象，只关注被测单元的功能逻辑。

2、被测单元依赖的模块尚未开发完成A，而被测单元需要依赖模块的返回值进行后续处理。

3、前后端项目中，后端接口开发完成之前，接口联调

4、依赖的上游项目的接口尚未开发完成，需要接口联调测试

5、被测单元依赖的对象较难模拟或者构造比较复杂

如: 支付业务的异常条件很多，但是模拟这种异常条件很复杂或者无法模拟.

4、代码实例

新建测试工程

  1.  
  2. package com.echo.mockito;
  3.  
  4.  
  5.  
  6. public class demo {
  7.  
  8.  
  9.  
  10.     //新建一个测试方法
  11.  
  12.     public int add(int a,  int b){
  13.  
  14.         return a + b;
  15.  
  16.     }
  17.  
  18. }

构建mock测试方法

选中测试类，右键选中generate

2.png

点击test

3.png

点击ok后就会在test目录下生成对应的测试方法，和真实的目录是对应的

4.png

5、参数方法说明

@BeforeEach

用在测试前准备，测试前会构建很多的环境配置或者基础配置，都可以在这里设置。

@AfterEach

用于测试后设置。

@Mock

注解可以理解为对 mock 方法的一个替代，不会走真实的方法，模拟真实方法的行为。使用该注解时，要使用MockitoAnnotations.openMocks(this)  方法，让注解生效。

@Spy

1、被Spy的对象会走真实的方法，而mock对象不会，

2、spy方法的参数是对象实例，mock的参数是class。

@InjectMocks

用于将@Mock标记的模拟变量注入到测试类中。

MockitoAnnotations.openMocks(this)

开启mock，配合以上两个注解进行测试。一般放在@BeforeEach 中，在测试前开启，这样不用在每个方法中都的开启了。

Mockito.when(demo.add(1,2)).thenReturn(3)：打桩

mock核心，可以设置要测试的方法的结果，这样就会忽略真实方法的执行结果，后续的测试都是基于打桩结果执行。

Mockito.when(demo.add(1,2)).thenThrow(new RuntimeException());

用于模拟异常。

Assertions.assertEquals(3,demo.add(1,2))：断言

测试的主要方式，结果基于此判断。(期望值，实际值)。

6、简单测试

打桩测试  设置方法返回4  ，而实际执行为3 ，测试不通过。

5.png

不打桩测试  因为是spy方式，会走真实的方法  ，测试通过。

6.png

如果是mock方式，如果不打桩会有默认值，测试会不通过，可以试一下。

7.png

7、测试方法说明

详细调用看代码，一般会以下几种：

  • 打桩测试

  • 异常测试

  • 真实方法调用

  1.  
  2. package com.echo.mockito;
  3.  
  4.  
  5.  
  6. import org.junit.jupiter.api.AfterEach;
  7.  
  8. import org.junit.jupiter.api.Assertions;
  9.  
  10. import org.junit.jupiter.api.BeforeEach;
  11.  
  12. import org.junit.jupiter.api.Test;
  13.  
  14. import org.mockito.Mock;
  15.  
  16. import org.mockito.Mockito;
  17.  
  18. import org.mockito.MockitoAnnotations;
  19.  
  20. import org.mockito.Spy;
  21.  
  22.  
  23.  
  24.  
  25.  
  26. class demoTest {
  27.  
  28.  
  29.  
  30.      @Mock
  31.  
  32.      demo demo;
  33.  
  34.      //测试前开启mock
  35.  
  36.     @BeforeEach
  37.  
  38.     void setUp() {
  39.  
  40.         MockitoAnnotations.openMocks(this);
  41.  
  42.     }
  43.  
  44.  
  45.  
  46.     @Test
  47.  
  48.     void add() {
  49.  
  50.         //mock 打桩，就是不管真实的方法如何执行，我们可以自行假设该方法执行的结果
  51.  
  52.         //后续的测试都是基于打桩结果来走
  53.  
  54.        // Mockito.when(demo.add(1,2)).thenReturn(4);
  55.  
  56.        // Assertions.assertEquals(3,demo.add(1,2));
  57.  
  58.         //当测试方法出现异常，测试方法  如果有try{}catch{} 则可以测试异常是否正常
  59.  
  60.         //Mockito.when(demo.add(1,1)).thenThrow(new RuntimeException());
  61.  
  62.         //调用真实的方法
  63.  
  64.         Mockito.when(demo.add(1,1)).thenCallRealMethod();
  65.  
  66.         Assertions.assertEquals(2,demo.add(1,1));
  67.  
  68.     }
  69.  
  70.  
  71.  
  72.     @AfterEach
  73.  
  74.     void after(){
  75.  
  76.         System.out.println("测试结束");
  77.  
  78.     }
  79.  
  80. }

8、Mock静态方法

之前的版本中是不允许模拟测试静态方法的，如果需要测试静态方法，需要替换新的mock依赖，注释掉目前有的依赖，会有冲突。

静态方法测试要用mock的MockedStatic类构建测试方法。

  1.  
  2.   <!--   <dependency>
  3.  
  4.             <groupId>org.mockito</groupId>
  5.  
  6.             <artifactId>mockito-core</artifactId>
  7.  
  8.             <version>4.6.1</version>
  9.  
  10.         </dependency>
  11.  
  12. -->
  13.  
  14.         <dependency>
  15.  
  16.             <groupId>org.mockito</groupId>
  17.  
  18.             <artifactId>mockito-inline</artifactId>
  19.  
  20.             <version>4.3.1</version>
  21.  
  22.             <scope>test</scope>
  23.  
  24.         </dependency>
  25.  
  26.  
  27. package com.echo.mockito.Util;
  28.  
  29.  
  30.  
  31. import org.junit.jupiter.api.Assertions;
  32.  
  33. import org.junit.jupiter.api.BeforeEach;
  34.  
  35. import org.junit.jupiter.api.Test;
  36.  
  37. import org.mockito.MockedStatic;
  38.  
  39. import org.mockito.Mockito;
  40.  
  41.  
  42.  
  43. import java.util.Arrays;
  44.  
  45.  
  46.  
  47. import static org.junit.jupiter.api.Assertions.*;
  48.  
  49.  
  50.  
  51. class StaticUtilsTest {
  52.  
  53.  
  54.  
  55.     @BeforeEach
  56.  
  57.     void setUp() {
  58.  
  59.     }
  60.  
  61.  
  62.  
  63.     // 有参静态方法构建
  64.  
  65.     @Test
  66.  
  67.     void range() {
  68.  
  69.         MockedStatic   demo = Mockito.mockStatic(StaticUtils.class);
  70.  
  71.         //打桩
  72.  
  73.         demo.when(()->StaticUtils.range(2,6)).thenReturn(Arrays.asList(10,11,12));
  74.  
  75.         Assertions.assertTrue(StaticUtils.range(2,6).contains(11));
  76.  
  77.     }
  78.  
  79.     // 无参静态方法构建
  80.  
  81.     @Test
  82.  
  83.     void name() {
  84.  
  85.         MockedStatic   demo = Mockito.mockStatic(StaticUtils.class);
  86.  
  87.         //打桩
  88.  
  89.         demo.when(StaticUtils::name).thenReturn("dhmw");
  90.  
  91.         Assertions.assertEquals("dhmw",StaticUtils.name());
  92.  
  93.  
  94.  
  95.     }
  96.  
  97. }

问题：单个的方法执行是没有问题的，但是我们在类上全部执行的时候，发现报错。

提示static mocking is already registered in the current thread  To create a new mock, the existing static mock registration must be deregistered

意思就是说，每个方法需要有自己的static mock 对象，不允许公用。一起执行的时候，第一个方法占了对象，第二个方法就没有办法再占了。

8.png

解决：每个方法执行完毕后就直接关闭mock对象 demo.close()。相当于是单例的。用完后就的释放，下一个方法才能接着使用。

  1.  
  2.   @Test
  3.  
  4.     void range() {
  5.  
  6.         MockedStatic   demo = Mockito.mockStatic(StaticUtils.class);
  7.  
  8.         //打桩
  9.  
  10.         demo.when(()->StaticUtils.range(2,6)).thenReturn(Arrays.asList(10,11,12));
  11.  
  12.         Assertions.assertTrue(StaticUtils.range(2,6).contains(11));
  13.  
  14.        //关闭
  15.  
  16.         demo.close();
  17.  
  18.     }
  19.  
  20.     // 无参静态方法构建
  21.  
  22.     @Test
  23.  
  24.     void name() {
  25.  
  26.         MockedStatic   demo = Mockito.mockStatic(StaticUtils.class);
  27.  
  28.         //打桩
  29.  
  30.         demo.when(StaticUtils::name).thenReturn("dhmw");
  31.  
  32.         Assertions.assertEquals("dhmw",StaticUtils.name());
  33.  
  34.         //关闭
  35.  
  36.         demo.close();
  37.  
  38.     }

9、提升测试覆盖率

案例：数据统计系统，地推人员输入客户的姓名和手机号码，最后构建用户对象存入数据表。

业务代码如下：

  1.  
  2. package com.echo.mockito.service.impl;
  3.  
  4.  
  5.  
  6. import com.echo.mockito.dao.UserDao;
  7.  
  8. import com.echo.mockito.service.RegistrationService;
  9.  
  10. import com.echo.mockito.vo.User;
  11.  
  12. import org.springframework.beans.factory.annotation.Autowired;
  13.  
  14.  
  15.  
  16. import javax.xml.bind.ValidationException;
  17.  
  18. import java.sql.SQLException;
  19.  
  20.  
  21.  
  22. public class RegistrationServiceImpl implements RegistrationService {
  23.  
  24.      @Autowired
  25.  
  26.      UserDao userDao;
  27.  
  28.     @Override
  29.  
  30.     public User register(String name, String phone) throws Exception {
  31.  
  32.         if (name == null || name.length() == 0){
  33.  
  34.             throw new ValidationException("name 不能为空");
  35.  
  36.         }
  37.  
  38.         if (phone == null || phone.length() ==0 ){
  39.  
  40.             throw new ValidationException("phone 不能为空");
  41.  
  42.         }
  43.  
  44.         User user;
  45.  
  46.         try {
  47.  
  48.               user = userDao.save(name,phone);
  49.  
  50.         }catch (Exception e){
  51.  
  52.             throw  new Exception("SqlException thrown" + e.getMessage());
  53.  
  54.         }
  55.  
  56.         return user;
  57.  
  58.     }
  59.  
  60. }

  1.  
  2. package com.echo.mockito.dao;
  3.  
  4.  
  5.  
  6. import com.echo.mockito.vo.User;
  7.  
  8.  
  9.  
  10. public class UserDao {
  11.  
  12.  
  13.  
  14.     public User save(String name,String phnoe){
  15.  
  16.         User user = new User();
  17.  
  18.         user.setName(name);
  19.  
  20.         return user;
  21.  
  22.     }
  23.  
  24. }

生成相应的测试代码，此时有几个问题需要思考。

1、测试的类是RegistrationServiceImpl但是里面的userDao如何注入到测试类中？

2、因为需要测试覆盖度，需要考虑该测试类中总共有几种情况需要测试。

（1）：两个if抛出了两个异常，总共是2种情况要测试。

（2）：保存数据库分为正常保存和异常保存，总共2种情况测试。

综上所述，必须完成这四种情况的测试，才能覆盖所有代码。

相同的方法，我们生成测试用例.代码中有详细的说明，每一种情况都有测试用例。

  1.  
  2. package com.echo.mockito.service.impl;
  3.  
  4.  
  5.  
  6. import com.echo.mockito.dao.UserDao;
  7.  
  8. import com.echo.mockito.vo.User;
  9.  
  10. import org.junit.jupiter.api.Assertions;
  11.  
  12. import org.junit.jupiter.api.BeforeEach;
  13.  
  14. import org.junit.jupiter.api.Test;
  15.  
  16. import org.mockito.*;
  17.  
  18.  
  19.  
  20. import javax.xml.bind.ValidationException;
  21.  
  22.  
  23.  
  24. import java.sql.SQLException;
  25.  
  26.  
  27.  
  28. import static org.junit.jupiter.api.Assertions.*;
  29.  
  30.  
  31.  
  32. class RegistrationServiceImplTest {
  33.  
  34.  
  35.  
  36.   @InjectMocks     //RegistrationServiceImpl 实例中注入@Mock标记的类，此处是注入userDao
  37.  
  38.     @Spy
  39.  
  40.     private RegistrationServiceImpl registrationService;
  41.  
  42.     @Mock
  43.  
  44.     private  UserDao userDao;
  45.  
  46.     @BeforeEach
  47.  
  48.     void setUp() {
  49.  
  50.         MockitoAnnotations.openMocks(this);
  51.  
  52.     }
  53.  
  54.  
  55.  
  56.     @Test
  57.  
  58.     void register() throws Exception {
  59.  
  60.         // ------------------  第一种 name  异常情况   测试   start ------------------------
  61.  
  62.         String name = null;
  63.  
  64.         String phone = "1234";
  65.  
  66.         try {
  67.  
  68.           registrationService.register(name,phone);
  69.  
  70.         }catch (Exception e){
  71.  
  72.         Assertions.assertTrue(e instanceof ValidationException);
  73.  
  74.         }
  75.  
  76.  
  77.  
  78.         // ------------------  name  异常情况   测试   end  ------------------------
  79.  
  80.  
  81.  
  82.         // ------------------  第二种 phone  异常情况   测试   start  ------------------------
  83.  
  84.         name = "111";
  85.  
  86.         phone = null;
  87.  
  88.       try {
  89.  
  90.         registrationService.register(name,phone);
  91.  
  92.       }catch (Exception e){
  93.  
  94.         Assertions.assertTrue(e instanceof ValidationException);
  95.  
  96.       }
  97.  
  98.         // ------------------  phone  异常情况   测试   start  ------------------------
  99.  
  100.  
  101.  
  102.  
  103.  
  104.         // ------------------  第三种 userDao.save   正常情况   测试   start  ------------------------
  105.  
  106.       name = "111";
  107.  
  108.       phone = "111";
  109.  
  110.         //正常保存测试  打桩  走真实的方法
  111.  
  112.         Mockito.when(userDao.save(name,phone)).thenCallRealMethod();
  113.  
  114.         User user =  registrationService.register(name,phone);
  115.  
  116.         Assertions.assertEquals("111",user.getName());
  117.  
  118.         // ------------------  userDao.save   正常情况   测试   end  ------------------------
  119.  
  120.  
  121.  
  122.         // ------------------   第四种 userDao.save   异常情况   测试   start  ------------------------
  123.  
  124.       //异常保存测试  打桩   通过thenThrow 抛出异常  测试异常是否被捕获
  125.  
  126.       Mockito.when(userDao.save(name,phone)).thenThrow(new RuntimeException());
  127.  
  128.       try {
  129.  
  130.          registrationService.register(name,phone);
  131.  
  132.       }catch (Exception e){
  133.  
  134.         Assertions.assertTrue(e instanceof Exception);
  135.  
  136.       }
  137.  
  138. // ------------------  userDao.save   异常情况   测试   end  ------------------------
  139.  
  140.     }
  141.  
  142. }

如上所示：上面提到的第一个问题，如何注入测试类中的成员变量，是通过@InjectMocks 注解即可完成。

测试覆盖率方法如下：

9.png

测试结果如下：

1、右边部分会显示测试覆盖率。

2、真实代码绿色代表已覆盖测试，红色代表未覆盖测试。

11.png

如果所有的测试情况都100%覆盖，结果如下：

12.png

综上所述就是覆盖测试的方法，总结如下：

1、根据业务代码，分析出所有需要测试的情况。

2、根据不同的测试情况，编写具体的测试代码。

3、针对每一种情况，可以编写具体的测试代码，然后通过打桩，断言等方式，穷尽所有的清册情况即可。

问题：

1、如果真实代码 方法级别有 throws Exception  那么同样的，测试方法也必须方法级别要抛出异常，不然测试会报错。

  1.  
  2.     @Test
  3.  
  4.     void register() throws Exception {

 2、保存数据库分为正常和异常，那么先测正常分支，然后在测试异常分支，如果顺序反了，测试先抛出异常，正常的分支就不会执行，这样会导致测试覆盖不全。

行动吧，在路上总比一直观望的要好，未来的你肯定会感 谢现在拼搏的自己！如果想学习提升找不到资料，没人答疑解惑时，请及时加入扣群： 320231853，里面有各种软件测试+开发资料和技术可以一起交流学习哦。

最后感谢每一个认真阅读我文章的人，礼尚往来总是要有的，虽然不是什么很值钱的东西，如果你用得到的话可以直接拿走：

​

这些资料，对于【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴上万个测试工程师们走过最艰难的路程，希望也能帮助到你！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/895874
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号