SpringBoot——单元测试实践总结

系统管理员 2024-03-26 15:37 65阅读 0赞

#### 文章目录 ####

*  单元测试
 *   *  概念
     *  作用
     *  黑白盒
     *   *  黑盒测试
         *  白盒测试
         *  逻辑覆盖
         *  1、语句覆盖
         *  2、判定覆盖
         *  3、条件覆盖
         *  4、条件/判定覆盖
         *  5、条件组合覆盖
         *  6、路径覆盖
 *  SpringBoot工程单测介绍
 *   *  pom依赖
     *   *  注意：
     *  Idea结构
     *   *  创建路径
         *  创建类和方法
     *  Controller层单测
     *   *  被测代码
         *  测试代码
     *  Service层单测
     *   *  被测代码
         *  测试代码
 *  单测规约
 *  PowerMock框架
 *   *  mock介绍
     *   *  mock概念
         *  mock作用
     *  PowerMock介绍
     *   *  PowerMock pom依赖
         *   *  注意：
         *  PowerMock 功能
         *  PowerMock 常用mock示例
         *   *  mock模板
             *  mock私有构造方法
             *  mock私有方法和私有属性
             *  mock静态方法
             *  mock配置
             *  mock对象类的公有方法值返回
 *  排雷
 *   *  @SpringBootTest
     *   *  问题：
         *  解决方案：
     *  SpringBoot+PowerMock+Mockito结合使用
     *   *  问题：
         *  解决方案：
     *  构造函数注入类
     *   *  问题：
         *  解决方案：
     *  静态方法mock时报错org.powermock.api.mockito.ClassNotPreparedExceptionnot
     *   *  问题：
         *  解决方案：
     *  mybatis报错MybatisPlusException
     *   *  问题：
         *  解决方案：
 *  参考

## 单元测试 ##

### 概念 ###

> 在计算机编程中，单元测试（英语：Unit Testing）又称为模块测试，是针对程序模块（软件设计的最小单位）来进行正确性检验的测试工作。 程序单元是应用的最小可测试部件。在过程化编程中，一个单元就是单个程序、函数、过程等；对于面向对象编程，最小单元就是方法，包括基类（超类）、抽象类、或者派生类（子类）中的方法。——维基百科

### 作用 ###

1.  提质  
    单测可以一定程度上减少潜在bug，提高代码质量。单测不仅解决覆盖率问题，也可以覆盖代码块中的一些边界和异常处理问题。
2.  重构  
    单测可以为后续其他小伙伴修改、重构代码保驾护航，因为你只要敢乱改代码，单测就敢给你报错。
3.  调试  
    单测有助于代码调试，我们可以按照需求进行依赖类、方法和参数的mock，无需下游类、方法的真实调用。
4.  CodeReview  
    单测也是一种自我CodeReview的过程。对功能单元的主流程、分支、边界以及异常情况进行分别测试，有助于复查代码的逻辑设计是否合理。反向督促自己提高编码质量意识。特别是，一个方法几百行，写单测时，你会发现这一坨，为何不拆一拆？

### 黑白盒 ###

#### 黑盒测试 ####

![6da5c1bffa21c2c9010f4ef92d5ab820.png][]

黑盒测试又称为`功能测试`或`数据驱动测试`，测试过程中，程序看作成一个黑色盒子，看不到盒子内部代码结构。  
  黑盒测试主要根据功能需求设计测试用例进行测试，是一种从软件外部实施的测试方式。多次输入参数，测试查看程序是否正常或达到预期。  
  黑盒只知道软件的功能（能干什么），但是不知道软件的实现（怎么干的）。

#### 白盒测试 ####

![64b3df840a2a990a38a1ee6860ba2ea8.png][]

白盒测试又称为`结构测试`或`逻辑驱动测试`，测试过程中，程序看作一个透明盒子，能够看清盒子内部的代码和结构，这样测试人员对程序代码的逻辑有所知晓。  
  穷举路径的方式传参，检查代码所有结构是否正常或符合预期。单元测试属于白盒测试。  
  白盒知道软件的实现（怎么干的），不需要管软件的功能（能干什么）。

#### 逻辑覆盖 ####

#### 1、语句覆盖 ####

程序每条可执行语句至少执行一次，即测试用例覆盖所有语句。

#### 2、判定覆盖 ####

也称为分支覆盖，针对判定表达式，true或false两种真假判定，程序中每一个判断的分支至少经历一次。  
  比如，判定表达式：`a > 0 && b > 0`  
  设计测试数据

a > 0 && b > 0（判定表达式的值为“真”）
    a <= 0 && b <= 0（判定表达式的值为“假”）

满足判定的所有分支覆盖（此时真、假分支都覆盖）。

#### 3、条件覆盖 ####

针对判断语句中的条件，程序中每个判断中的每个条件取值至少满足一次，针对条件语句。  
  比如，判定表达式：`a > 0 && b > 0`  
  设计测试数据

a <= 0 && b <= 0（判定表达式的值为“假”）
    a > 0 && b <= 0（判定表达式的值为“假”）

保证每个条件取值一次，而不管分支是否覆盖全面（此时只覆盖假分支）。

#### 4、条件/判定覆盖 ####

判定条件中所有可能条件成立与否至少执行一次取值、所有真假判断的可能结果至少执行一次。  
  比如，判定表达式：`a > 0 && b > 0`  
  设计测试数据

a > 0 && b > 0（判定表达式的值为“真”）
    a <= 0 && b <= 0（判定表达式的值为“假”）

#### 5、条件组合覆盖 ####

所有可能的条件取值组合至少执行一次。  
  比如，判定表达式：`a > 0 && b > 0`  
  设计测试数据

a > 0 && b > 0（判定表达式的值为“真”）
    a <= 0 && b <= 0（判定表达式的值为“假”）
    a > 0 && b <= 0（判定表达式的值为“假”）
    a <= 0 && b > 0（判定表达式的值为“假”）

判定中所有可能的条件组合。

#### 6、路径覆盖 ####

所有可能执行的路径。

## SpringBoot工程单测介绍 ##

### pom依赖 ###

<dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-test</artifactId> 
    <scope>test</scope> 
    </dependency>

#### 注意： ####

1.  该依赖版本一般是跟着对应的SpringBoot版本走，不需要手动指定。
2.  该依赖会自动引入相关依赖：  
    JUnit  
    Mockito  
    Spring Test  
    … …

### Idea结构 ###

#### 创建路径 ####

![88c230175315979fb3a6a9390263e35b.png][]

与src/main同级目录，创建src/test，其他类路径与main包中保持一致。（可通过创建类的快捷方法自动创建路径）

#### 创建类和方法 ####

创建类对应单测类的快捷方法：只需将双击这个类，鼠标右键，然后选择go to到Test。

![6b0d89bb8e333608321caa88cd7b6532.png][]

选择要测试的方法，同时，可以选择JUnit版本等，点击OK

![145d7e69985a74e6f5cf5fa4f3f190fe.png][]

### Controller层单测 ###

#### 被测代码 ####

@Slf4j
    @RestController
    @RequestMapping("/demo")
    @Api(value = "DemoController", tags = "Demo管理模块")
    public class DemoController implements DemoApi {
        
        /**
         * service
         */
        @Autowired
        private DemoService demoService;
    
    
        @Override
        @ApiOperation(value = "新增", notes = "新增")
        @PostMapping("/create")
        public Boolean add(@RequestHeader("appCode") String appCode,
                                         @RequestBody DemoDTO demoDTO) {
        
            boolean addFlag = demoService.add(demoDTO);
            if (addFlag) {
        
                // 刷新资源
              demoService.refreshMap(appCode);
            }
            return addFlag;
        }
    
    
        @Override
        @ApiOperation(value = "修改", notes = "修改")
        @PostMapping("/update")
        public Boolean update(@RequestHeader("appCode") String appCode,
                                            @RequestBody DemoDTO demoDTO) {
        
          
            boolean addFlag = demoService.update(demoDTO);
            if (addFlag) {
        
                // 刷新资源
              demoService.refreshMap(appCode);
            }
            return addFlag;
        }
    
    
        @Override
        @ApiOperation(value = "删除", notes = "删除")
        @DeleteMapping("/delById")
        public Boolean deleteById(@RequestHeader("appCode") String appCode, @RequestParam Long id) {
        
            boolean deleteFlag = demoService.deleteById(id);
            if (deleteFlag) {
        
                // 刷新资源
              demoService.refreshMap(appCode);
            }
            return addFlag;
        }
    
    
        @Override
        @ApiOperation(value = "列表", notes = "列表")
        @GetMapping("/list")
        public List<DemoVO> list() {
        
            return demoService.list();
        }
     }

#### 测试代码 ####

1.  单独组件测试，无需使用@SpringBootTest进行整体上下文启动，使用@RunWith(SpringRunner.class)运行测试用例。
2.  使用@InjectMock注入controller类。
3.  使用@Mock注解mock service类。

@RunWith(SpringRunner.class)
    public class DemoControllerTest {
        
        /**
         * mock mvc
         */
        private MockMvc mockMvc;
    
    
        /**
         * 注入实例
         */
        @InjectMocks
        private DemoController demoController;
    
    
        /**
         * service mock
         */
        @Mock
        private DemoService demoService;
        
        /**
         * appCode
         */
        private String appCode;
    
    
        /**
         * before设置
         */
        @Before
        public void setUp() {
        
            //初始化带注解的对象
            MockitoAnnotations.openMocks(this);
            //构造mockmvc
            mockMvc = MockMvcBuilders.standaloneSetup(demoController).build();
            //appCode
            appCode = "AppCode_test";
        }
    
    
        /**
         * 测试testAdd
         */
        @Test
        public void testAdd() throws Exception {
        
            //构建dto
            DemoDTO demoDTO = new DemoDTO();
            //setId
            demoDTO.setId(-1L);
            //setName
            demoDTO.setName("test");
            //mock service方法
       		PowerMockito.when(demoService.add(demoDTO)).thenReturn(true);
            //构造body
            String body = JSONObject.toJSONString(demoDTO);
            //执行mockmvc
            this.mockMvc.perform(MockMvcRequestBuilders.post("/demo/create")
                    //传参
                    .header("appCode", appCode).content(body).contentType(MediaType.APPLICATION_JSON_VALUE))
                    //mock返回
                    .andExpect(status().isOk()).andDo(MockMvcResultHandlers.print()).andReturn();
        }
    
    
        /**
         * 测试testUpdate
         */
        @Test
        public void testUpdate() throws Exception {
        
              //构建dto
            DemoDTO demoDTO = new DemoDTO();
            //setId
            demoDTO.setId(-1L);
            //setName
            demoDTO.setName("test");
            //mock service方法
            PowerMockito.when(demoService.update(demoDTO)).thenReturn(true);
            //构造body
            String body = JSONObject.toJSONString(demoDTO);
            //执行mockmvc
            this.mockMvc.perform(MockMvcRequestBuilders.post("/demo/update")
                    //传参
                    .header("appCode", appCode).content(body).contentType(MediaType.APPLICATION_JSON_VALUE))
                    //mock返回
                    .andExpect(status().isOk()).andDo(MockMvcResultHandlers.print()).andReturn();
        }
    
    
        /**
         * 测试testDelete
         */
        @Test
        public void testDelete() throws Exception {
        
            //Id
            Long id = 1000L;
            //mock service方法
            PowerMockito.when(demoService.deleteById(id)).thenReturn(true);
            //执行mockmvc 方法一
    //        this.mockMvc.perform(MockMvcRequestBuilders.delete("/demo/delById?id={id}",id)
    //                //传参
    //                .header("appCode", appCode).contentType(MediaType.APPLICATION_JSON_VALUE))
    //                //mock返回
    //.andExpect(status().isOk()).andDo(MockMvcResultHandlers.print()).andReturn();
    //    }
    		//方法二
            this.mockMvc.perform(MockMvcRequestBuilders.delete("/demo/delById")
                    //传参
                    .header("appCode", appCode).param("id", "1000").contentType(MediaType.APPLICATION_JSON_VALUE))
                    //mock返回
                    .andExpect(status().isOk()).andDo(MockMvcResultHandlers.print()).andReturn();
        }
    
    
        /**
         * 测试testList
         */
        @Test
        public void testList() throws Exception {
        
            this.mockMvc.perform(MockMvcRequestBuilders.get("/demo/list")
                    //传参
                    .contentType(MediaType.APPLICATION_JSON_VALUE))
                    //mock返回
                    .andExpect(status().isOk()).andDo(MockMvcResultHandlers.print()).andReturn();
        }
    }

### Service层单测 ###

#### 被测代码 ####

@Service 
    public class MenuService {
         
        @Autowired 
        private MenuMapper menuMapper; 
        
        @Transactional(readOnly = true) 
        public List<Menu> listMenus() {
         
            final List<Menu> result = menuMapper.list(); 
            return result; 
        }
    }

#### 测试代码 ####

1.  通过 `@TestConfiguration`创建一个测试用配置，该配置中提供了一个`MenuService Bean`的声明。
2.  该注解的使用有以下几个注意点：被注解的类须是 static 的，且不能是 private 的。建议用在使用在内部类上，否则所定义的 Bean 将不会被自动加载。须通过以下方式之一进行加载

@Import(MenuServiceTestConfig.class)
    @ContextConfiguration(classes =MenuServiceTestConfig.class)
    @Autowired
    //此处通过 @Autowired 自动注入的是上面通过 @TestConfiguration 声明的 Bean。
    @RunWith(SpringRunner.class) 
    public class MenuServiceTest {
         
        @TestConfiguration 
        static class MenuServiceTestConfig {
         
            @Bean 
            public MenuService mockMenuService() {
         
                return new MenuService(); 
            } 
        }
        @Autowired 
        private MenuService MenuService; 
        @MockBean 
        private MenuMapper MenuMapper; 
        @Test 
        public void listMenus() {
         
            List<Menu> menus = new ArrayList<Menu>() {
        {
         
                this.add(new Menu()); 
            }}; 
            Mockito.when(menuMapper.list()).thenReturn(menus); 
            List<Menu> result = menuService.listMenus(); 
            Assertions.assertThat(result.size()).isEqualTo(menus.size()); 
        } 
    }

## 单测规约 ##

1.  **【强制】好的单元测试必须遵守AIR原则。**  
    说明：单元测试在线上运行时，感觉像空气（AIR）一样并不存在，但在测试质量的保障上，却是非常关键的。好的单元测试宏观上来说，具有自动化、独立性、可重复执行的特点。

A：Automatic（自动化）
    I：Independent（独立性）
    R：Repeatable（可重复）

1.  **【强制】单元测试应该是全自动执行的，并且非交互式的。**  
    说明：测试用例通常是被定期执行的，执行过程必须完全自动化才有意义。输出结果需要人工检查的测试不是一个好的单元测试。单元测试中不准使用System.out来进行人肉验证，必须使用assert来验证。
2.  **【强制】保持单元测试的独立性。**  
    说明：为了保证单元测试稳定可靠且便于维护，单元测试用例之间决不能互相调用，也不能依赖执行的先后次序。  
    反例：method2需要依赖method1的执行，将执行结果作为method2的输入。
3.  **【强制】单元测试是可以重复执行的，不能受到外界环境的影响。**  
    说明：单元测试通常会被放到持续集成中，每次有代码check in时单元测试都会被执行。如果单测对外部环境（网络、服务、中间件等）有依赖，容易导致持续集成机制的不可用。  
    正例：为了不受外界环境影响，要求设计代码时就把SUT的依赖改成注入，在测试时用spring 这样的DI框架注入一个本地（内存）实现或者Mock实现。
4.  **【强制】对于单元测试，要保证测试粒度足够小，有助于精确定位问题。单测粒度至多是类级别，一般是方法级别。**  
    说明：只有测试粒度小才能在出错时尽快定位到出错位置。单测不负责检查跨类或者跨系统的交互逻辑，那是集成测试的领域。
5.  **【强制】核心业务、核心应用、核心模块的增量代码确保单元测试通过。**  
    说明：新增代码及时补充单元测试，如果新增代码影响了原有单元测试，请及时修正。
6.  **【强制】单元测试代码必须写在如下工程目录：src/test/java，不允许写在业务代码目录下。**  
    说明：源码构建时会跳过此目录，而单元测试框架默认是扫描此目录。

## PowerMock框架 ##

### mock介绍 ###

#### mock概念 ####

mock是指在测试过程中，创建一个虚拟的对象来模拟指定对象的行为。

#### mock作用 ####

1.  service-A依赖于service-B，测试service-A时，service-B还未开发完，通过mock模拟service-B的一些行为达到测试效果。
2.  创建私有构造方法的对象，没法直接构建，可以通过mock构建。
3.  被测试的模块需连接数据库等操作，测试时无法保证一定能连接数据库，可通过mock实现。
4.  … …

### PowerMock介绍 ###

1.  PowerMock时一个Java单测模拟的框架，扩展了EasyMock和Mockito框架。
2.  PowerMock通过提供定制的类以及一些字节码篡改技巧进行模拟。
3.  PowerMock可模拟静态方法、私有方法、构造方法、final方法等。
4.  PowerMock支持JUnit和TestNG。

#### PowerMock pom依赖 ####

<properties>
        <powermock.version>2.0.9</powermock.version>
    </properties>
    <dependencies>
       <dependency>
          <groupId>org.powermock</groupId>
          <artifactId>powermock-module-junit4</artifactId>
          <version>${
        powermock.version}</version>
          <scope>test</scope>
       </dependency>
       <dependency>
          <groupId>org.powermock</groupId>
          <artifactId>powermock-api-mockito2</artifactId>
          <version>${
        powermock.version}</version>
          <scope>test</scope>
       </dependency>
    </dependencies>

##### 注意： #####

此依赖适合JUnit4.4及以上。

#### PowerMock 功能 ####

*  mock constructors
 *  mock final method or classes
 *  mock private methods
 *  mock static methods
 *  mock java system classes  
    各位小伙伴有兴趣的自己对着官网研究，版本重点介绍一些常用的mock功能。

#### PowerMock 常用mock示例 ####

##### mock模板 #####

@RunWith(PowerMockRunner.class)
    @PowerMockRunnerDelegate(SpringRunner.class)
    @PrepareForTest({
        XxxUtils.class})
    public class DemoServiceImplTest {
        
        /**
         * 注入service
         */
        @InjectMocks
        private DemoServiceImpl demoService;
    
        /**
         * mapper
         */
        @MockBean
    private DemoMapper demoMapper;
    
    @Before
    public void setUp() {
        
          //构建mybatis缓存
          TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), DemoEntity.class);
    }
    
    @Test
    public void testCreateDemo() {
        
       //todo
    }
    }

##### mock私有构造方法 #####

![87694323e3ba54cad54a9c4ef937b06a.png][]

以部门封装的Result类为例，其中一些private构造方法无法构造参数，需mock构造。

Result<List<UserInfoDTO>> result = Whitebox.invokeConstructor(Result.class, "200", "", true, userInfoDTOList);

##### mock私有方法和私有属性 #####

//mock 当前service类
    ServiceA serviceMock= PowerMockito.mock(ServiceA.class);
    //内部调用其他service需设置非公共成员
    Whitebox.setInternalState(serviceMock, "serviceB", serviceB);
    //mock调用其他service方法
    PowerMockito.when(serviceB.getStr("xxx")).thenReturn("xxxxx");
    //调用内部私有方法
    Whitebox.invokeMethod(serviceMock, "privateMethod1", demoDto);

说明：

1.  ServiceA类中注入了ServiceB类，并调用了getStr(String str)方法。
2.  ServiceA类中私有方法privateMethod1，传参DemoDto。

##### mock静态方法 #####

1.  添加需要被测试的静态方法注解

@PrepareForTest({
        StaticXXX.class})

1.  测试mock调用

//mock静态类
    PowerMockito.mockStatic(StaticXXX.class);
    //mock调用静态方法
    PowerMockito.when(StaticXXX.method01("param01", "param02")).thenReturn(xxx);

##### mock配置 #####

@MockBean
    private DemoProperties demoProperties ;

1.  使用@MockBean引入配置类
2.  调用塞值

//构造demoProperties 
    DemoProperties .DemoFirstProperties demoFirstProperties = new DemoProperties .DemoFirstProperties ();
    //塞值
    demoFirstProperties .setFirstParams("xxxx");
    //mock properties
    PowerMockito.when(demoProperties .getDemoFirstProperties ()).thenReturn(demoFirstProperties );

##### mock对象类的公有方法值返回 #####

1.  对象类

public class SmsResponse implements Serializable {
        
        /**
         * 编码 1-成功
         */
        private Integer code;
        /**
         * 返回内容
         */
        private String msg;
        public boolean isSuccess(){
        
            return null != code && 200 == code;
        }
        public Integer getCode() {
        
            return code;
        }
        public void setCode(Integer code) {
        
            this.code = code;
        }
        public String getMsg() {
        
            return msg;
        }
        public void setMsg(String msg) {
        
            this.msg = msg;
        }
    }

1.  此类中的isSuccess()方法调用返回值在代码中使用

// 发送短信
    SmsResponse smsResponse = this.smsNoticeService.sendSms(sms);
    if (smsResponse.isSuccess()) {
        
        if (Objects.nonNull(noticeTimes) && Objects.nonNull(smsNotice)) {
        
            // 短信发送成功，更新通知标识
            noticeTimes.put(NoticeChannelEnum.SMS.getDesc(),smsNotice);
        }
        result.put(MSG,"");
        return result;
    }

此时若想进入到if分支内，就需要mock操作

SmsResponse smsResponse = PowerMockito.mock(SmsResponse.class);
    PowerMockito.when(smsResponse.isSuccess()).thenReturn(true);
    when(this.smsNoticeService.sendSms(any(Sms.class))).thenReturn(smsResponse);

## 排雷 ##

### @SpringBootTest ###

#### 问题： ####

1.  @SpringBootTest会扫描应用程序的Spring配置，并构建完整的Spring Context。每次执行一个类的单元测试，都需要启动整个上下文，单测速度慢！
2.  @SpringBootTest加载Spring上下文时，可能会因为服务中使用的数据库、MQ、缓存等配置加载失败而导致测试类启动。
3.  @SpringBootTest更适合功能集成测试。

#### 解决方案： ####

使用@RunWith（SpringRunner.class)声明该测试是在Spring环境中进行，这样Spring相关注解就会被识别生效。

### SpringBoot+PowerMock+Mockito结合使用 ###

#### 问题： ####

结合powermock使用时，容易造成一些类和方法的冲突，导致方法找不到。

#### 解决方案： ####

依赖版本对应：

<table> 
 <thead> 
  <tr> 
   <th>Mockito</th> 
   <th>PowerMock</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>2.8.9+</td> 
   <td>2.x</td> 
  </tr> 
  <tr> 
   <td>2.8.0-2.8.9</td> 
   <td>1.7.x</td> 
  </tr> 
  <tr> 
   <td>2.7.5</td> 
   <td>1.7.0RC4</td> 
  </tr> 
  <tr> 
   <td>2.4.0</td> 
   <td>1.7.0RC2</td> 
  </tr> 
  <tr> 
   <td>2.0.0-beta - 2.0.42-beta</td> 
   <td>1.6.5-1.7.0RC</td> 
  </tr> 
  <tr> 
   <td>1.10.8 - 1.10.x</td> 
   <td>1.6.2 - 2.0</td> 
  </tr> 
  <tr> 
   <td>1.9.5-rc1 - 1.9.5</td> 
   <td>1.5.0 - 1.5.6</td> 
  </tr> 
  <tr> 
   <td>1.9.0-rc1 &amp; 1.9.0</td> 
   <td>1.4.10 - 1.4.12</td> 
  </tr> 
  <tr> 
   <td>1.8.5</td> 
   <td>1.3.9 - 1.4.9</td> 
  </tr> 
  <tr> 
   <td>1.8.4</td> 
   <td>1.3.7 &amp; 1.3.8</td> 
  </tr> 
  <tr> 
   <td>1.8.3</td> 
   <td>1.3.6</td> 
  </tr> 
  <tr> 
   <td>1.8.1 &amp; 1.8.2</td> 
   <td>1.3.5</td> 
  </tr> 
  <tr> 
   <td>1.8</td> 
   <td>1.3</td> 
  </tr> 
  <tr> 
   <td>1.7</td> 
   <td>1.2.5</td> 
  </tr> 
 </tbody> 
</table>

### 构造函数注入类 ###

#### 问题： ####

有一些service类中注入的其他类，是通过构造函数注入，而非@Autowired或者@Resource注解。如

@Service 
    public class MenuService {
         
       
        private MenuMapper menuMapper; 
    @Autowired 
    public MenuService(final MenuMapper menuMapper) {
        
        this.menuMapper = menuMapper;
    }
    
        @Transactional(readOnly = true) 
        public List<Menu> listMenus() {
         
            final List<Menu> result = menuMapper.list(); 
            return result; 
        }
    }

#### 解决方案： ####

构造service

@RunWith(SpringRunner.class) 
    public class MenuServiceTest {
         
    
    private static final MenuMapper menuMapper = Mockito.mock(MenuMapper.class);
    
        @TestConfiguration 
        static class MenuServiceTestConfig {
         
            @Bean 
            public MenuService mockMenuService() {
         
                return new MenuService(menuMapper); 
            } 
        }
        @Autowired 
        private MenuService MenuService; 
        @MockBean 
        private MenuMapper MenuMapper; 
        @Test 
        public void listMenus() {
         
            List<Menu> menus = new ArrayList<Menu>() {
        {
         
                this.add(new Menu()); 
            }}; 
            Mockito.when(menuMapper.list()).thenReturn(menus); 
            List<Menu> result = menuService.listMenus(); 
            Assertions.assertThat(result.size()).isEqualTo(menus.size()); 
        } 
    }

### 静态方法mock时报错org.powermock.api.mockito.ClassNotPreparedExceptionnot ###

#### 问题： ####

mock静态方法时，报错该静态类prepared for test

![490c98cc1ee781ae2d83df7cbe586157.png][]

#### 解决方案： ####

1.  确认类上是否添加@PrepareForTest(\{Xxx.class\})注解进行静态类的准备。
2.  确认使用PowerMock时，是否使用了@RunWith(PowerMockRunner.class)运行环境。

### mybatis报错MybatisPlusException ###

#### 问题： ####

使用到lambda表达式有set方法的地方，单测报错`com.baomidou.mybatisplus.core.exceptions.MybatisPlusException: can not find lambda cache for this entity`

![64a4fa0e4c8f6dfefc6e5dd3e0547e24.png][]

#### 解决方案： ####

在单测类中@Before方法中加入代码手动触发缓存信息收集。

@Before
    public void setUp() {
        
        //构建mybatis缓存
        TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), XxxEntity.class);
    }

其中，XxxEntity.class为表实体类。

## 参考 ##

1.  [单测规约][Link 1]
2.  [junit官网][junit]
3.  [spring-boot-testing][]
4.  [mybatis-plus代码库][mybatis-plus]

[6da5c1bffa21c2c9010f4ef92d5ab820.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c563f1aab09c43438497b59a16584402.png
[64b3df840a2a990a38a1ee6860ba2ea8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/58b48ab264604edab6d5a3dca451fa9e.png
[88c230175315979fb3a6a9390263e35b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/dc3ff0705eb246af83a6c83a76177551.png
[6b0d89bb8e333608321caa88cd7b6532.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/3018af76c91d47c9907b7a514d31655a.png
[145d7e69985a74e6f5cf5fa4f3f190fe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/947bdc23b87f4b24af8435503e38f0b1.png
[87694323e3ba54cad54a9c4ef937b06a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/86a82c14f1f34df1afec8915f05b2ca5.png
[490c98cc1ee781ae2d83df7cbe586157.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5f1ebb0804e246fc877414a81c797c50.png
[64a4fa0e4c8f6dfefc6e5dd3e0547e24.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/9570f92bb3024d24aea09530c9dc1ba5.png
[Link 1]: https://github.com/alibaba/p3c/blob/master/p3c-gitbook/%E5%8D%95%E5%85%83%E6%B5%8B%E8%AF%95.md#L17
[junit]: https://junit.org/junit4/
[spring-boot-testing]: https://www.baeldung.com/spring-boot-testing
[mybatis-plus]: https://github.com/baomidou/mybatis-plus