用powermock编写单元测试

1、pom文件引入jar包

<!-- 单元测试 start -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-module-junit4</artifactId>
    <version>2.0.2</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-api-mockito2</artifactId>
    <version>2.0.2</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.github.jsonzou</groupId>
    <artifactId>jmockdata</artifactId>
    <version>4.1.2</version>
    <scope>test</scope>
</dependency>
<!-- 单元测试 end -->

2、创建单元测试用例目录

保持与main级别一致，并且具体的测试用例存放目录也跟源代码的目录级别保持一致

3、单元测试类的基本框架

@RunWith(PowerMockRunner.class)
@PrepareForTest({CommonUtils.class}) // 工具类
public class OrderServiceTest {
    @InjectMocks
    private OrderService orderService;
    @Mock
    private OrderMapper orderMapper;
    
    @Mock
    private OrderHelper orderHelper;
    
    @Before
    public void setUp() throws Exception {
        PowerMockito.mockStatic(CommonUtils.class);
    }
    
    // 被测试的方法 orderService.pageOrderRecord有返回值
    @Test
    public void testPageOrderRecord() {
    
        // Gievn
        OrderRecordDTO orderRecordDTO = new OrderRecordDTO();
        orderRecordDTO.setId("111");
        orderRecordDTO.setPageIndex(1);
        orderRecordDTO.setPageSize(10);
        // When
        OrderRecordEntity orderRecord = JMockData.mock(OrderRecordEntity.class);
        List<OrderRecordEntity> mock = Lists.newArrayList();
        mock.add(orderRecord);
        PowerMockito.when(orderMapper.selectEntityListPage(any())).thenReturn(mock); // mock的方法有返回值
        PowerMockito.doNothing().when(orderHelper).fillData(any()); // mock的方法没有返回值
        PowerMockito.when(CommonUtils.doPageQuery(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(new PageRows<>()); // mock工具类方法
        // Run the test
        PageRows<OrderRecordDTO> rt = orderService.pageOrderRecord(OrderRecordDTO);
        
        // Verify the results
        Assert.assertNotNull(rt);
    }
}

4、常见单元测试问题

4.1、静态方法如何mock

参见基本框架里的CommonUtils.doPageQuery()的mock。

如果被测试类的方法中调用到了静态方法CommonUtils.doPageQuery()，在写测试类的时候就需要主要注意：

@PrepareForTest（{CommonUtils.class}）、

PowerMockito.mockStatic(CommonUtils.class);

4.2、返回类型为void的方法如何mock

参见基本框架里的orderHelper.fillData()方法的mock。

4.3、被@Value注解的值如何mock

** ReflectionTestUtils.setField(对象,"成员变量","变量mock值");**

被测试类：

@Component
public class OrderExternalFacade {
    @Autowired
    private OrderAbility OrderAbility;
    @Autowired
    private OrderExternalConvertor OrderExternalConvertor;
    @Value("${switch.new.system:false}")
    protected boolean switchNewSystem;
    public PageRows<OrderVO> listOrder(OrderQueryVO OrderQueryVO) {
        if (switchNewSystem) {
            return OrderExternalConvertor.pageDto2PageVo(
                    OrderAbility.listOrder(OrderExternalConvertor.queryVo2ModelQuery(OrderQueryVO)));
        }
        return OrderExternalConvertor.pageDto2PageVo(
                    OrderAbility.listOrderFromEpm(OrderExternalConvertor.queryVo2QueryDto(OrderQueryVO)));
    }
}

单元测试类：

@RunWith(PowerMockRunner.class)
public class OrderExternalFacadeTest {
    @InjectMocks
    private OrderExternalFacade OrderExternalFacade;
    @Mock
    private OrderAbility OrderAbility;
    @Mock
    private OrderExternalConvertor OrderExternalConvertor;
    @Test
    public void listOrder() {
        ReflectionTestUtils.setField(OrderExternalFacade, "switchNewSystem", true);
        when(OrderExternalConvertor.queryVo2ModelQuery(any())).thenReturn(new OrderModelQueryDTO());
        when(OrderAbility.listOrder(any())).thenReturn(new PageRows<>());
        when(OrderExternalConvertor.pageDto2PageVo(any())).thenReturn(new PageRows<>());
        PageRows<OrderVO> rt = OrderExternalFacade.listOrder(new OrderQueryVO());
        Assert.assertNotNull(rt);
    }
}

4.4、返回类型为void的方法如何断言

验证调用次数：verify(OrderService, times(1)).insertOrder(orderBO);

被测试类：

public class OrderService{
    @Autowired
    private OrderDao OrderDao;
    
    /**
     * 添加订单
     * @param OrderBO
     * @throws Exception
     */
    @Override
    public void insertOrder(OrderBO OrderBO) throws Exception{
        OrderDao.insertOrder(OrderBO);
    }
}

单元测试类：

@RunWith(PowerMockRunner.class)
public class OrderServiceTest {
    @InjectMocks
    private OrderService OrderService;
    @Mock
    private OrderDao OrderDao;
    @Before
    public void setUp() throws Exception {}
    @Test
    public void testinsertOrder() throws Exception {
        OrderBO orderBO = new OrderBO();
        orderBO.setHandleType("order");
        orderBO.setBoId("1234568");
        orderBO.setHandeleSuggest("submit");
        // 如何mock 返回类型为void的方法
        PowerMockito.doNothing().when(OrderDao).insertOrder(any());
      
        //when
        OrderService.insertOrder(orderBO);
        
        verify(OrderService, times(1)).insertOrder(orderBO);
    }
}

4.5、异常如何断言

被测试类：

public void delete(List<String> ids, String requiredBillId) {
    RequiredBillEntity requiredBill = requiredBillMapper.selectEntity(requiredBillId);
    if (requiredBill == null){
        throw new BusinessException(RetCode.BUSINESSERROR_CODE, MessageConst.REQUIRED_BILL_NOT_FOUND);
    }
    if (!RequiredBillStatusEnum.DRAFT.getStatus().equals(requiredBill.getStatus())){
        throw new BusinessException(RetCode.BUSINESSERROR_CODE, MessageConst.REQUIRED_BILL_STATUS_NOT_DRAFT);
    }
    requiredBillDetailMapper.deleteEntities(new ParamsMap("id_IN", ids));
}

测试类：

@Test
public void testDelete() {
    List<String> ids = Lists.newArrayList();
    ids.add("dddd");
    String requiredBillId = "ddd";
    when(requiredBillMapper.selectEntity(anyString())).thenReturn(null);
    // 断言业务异常
    try {
        requiredBillDetailService.delete(ids,requiredBillId);
        fail("Expected BusiException");
    } catch (BusiException e) {
        assertEquals(RetCode.BUSINESSERROR_CODE, e.getExCode());
        assertEquals(REQUIRED_BILL_NOT_FOUND, e.getMessage());
    }
}

简洁的一点的话：

@Test
public void testDelete() {
    List<String> ids = Lists.newArrayList();
    ids.add("dddd");
    String requiredBillId = "ddd";
    when(requiredBillMapper.selectEntity(anyString())).thenReturn(null);
    // 断言业务异常
    Assert.assertThrows(BusinessException.class, () ->requiredBillDetailService.delete(requiredBillDetailDTO));
}