写UT：使用Junit写UT

最新推荐文章于 2024-02-06 17:21:57 发布
最新推荐文章于 2024-02-06 17:21:57 发布
阅读量669 收藏 1
点赞数
分类专栏： java UT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010986518/article/details/87349462
版权
java 同时被 2 个专栏收录
6 篇文章 0 订阅
订阅专栏
UT
3 篇文章 1 订阅
订阅专栏

在此之前我们需要弄清楚，在什么情况下使用mock写UT，在什么情况下使用Junit写UT。
大多数情况来说，不需要与数据库发生数据交互的使用mock，即查；与数据库发生交互的使用Junit写UT，即增、删、改。
当然还有特殊情况：逻辑很复杂，代码量很多，重构很彻底的一些功能方法使用Junit是很容易出错的，场景太多，无法全部覆盖到，我觉得应该使用mock测试比较好。功能重构之后=A模块+B模块，A有4种场景，B有三种场景，若使用mock，只需要模拟9重场景，而使用Junit，需要模拟4*5=20种场景。

一、Junit基类

以下给出了一个dao层的例子，我们只对其增、删、改部分使用Junit测试。

/**
 * Junit测试基类
 * 
 * @author Shuai Chen
 * 2018年12月17日   上午10:47:38
 *
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = BzSpringBootApplication.class)
@ActiveProfiles("dev")
public class BaseSpringBootTest {
    @Autowired
    //这里使用MongoTemplate是因为
    protected MongoTemplate mongoTemplate; 
    
    @Test
    public void 测试() { 
        
    }
}

二、被测试的类

@Log4j2
@Repository
public class InvoiceDaoImpl extends BaseDao implements InvoiceDao {

    @Override
    public void insertTrade(Trade trade) {
        getMongoTemplate().insert(trade);
    }

    @Override
    public void pushInvoice(Trade trade) {
        Query query = Query.query(Criteria.where(COL_ORDER_NO).is(trade.getOrderNo()));
        getMongoTemplate().updateFirst(query, getUpdatePushInvoice(trade.getInvoiceList()), Trade.class);
    }

    @Override
    public Integer updateRedBlueInvoice(Trade trade) {
        Criteria criteria = Criteria.where(COL_SHOP_CODE).is(trade.getShopCode());
        criteria.and(COL_ORDER_NO).is(trade.getOrderNo());
        criteria.and(COL_VERSION).is(trade.getVersion());
        Query query = new Query(criteria);

        Update update = newUpdate(trade);
        update.set(COL_INVOICE_LIST, trade.getInvoiceList());

        WriteResult writeResult = getMongoTemplate().updateFirst(query, update, Trade.class);
        return writeResult.getN();
    }

    @Override
    public void updateInvoiceStatus(Trade trade) {
        Invoice invoice = trade.getInvoiceList().iterator().next();

        Criteria criteria = Criteria.where(COL_SHOP_CODE).is(trade.getShopCode());
        criteria.and(QUERY_INVOICE_SERIA_NO).is(invoice.getSeriaNo());
        Query query = new Query(criteria);

        Update update = newUpdate(trade);

        update.set(COL_LAST_INVOICE_MODIFY_TIME, invoice.getLastModifyTime());
        update.set(COL_STATUS, invoice.getStatus());
        update.set(COL_ERROR_MSG, invoice.getErrorMsg());

        getMongoTemplate().updateFirst(query, update, Trade.class);
    }

    @Override
    public void updateInvoiceResult(Trade trade) {
        Invoice invoice = trade.getInvoiceList().iterator().next();
        Criteria criteria = new Criteria();
        criteria.and(QUERY_INVOICE_SERIA_NO).is(invoice.getSeriaNo());
        Query query = new Query(criteria);

        Update update = newUpdate(trade);
        if(Objects.nonNull(invoice.getLastModifyTime())){
            update.set(COL_LAST_INVOICE_MODIFY_TIME, invoice.getLastModifyTime());
        }
        if(Objects.nonNull(invoice.getStatus())){
            update.set(COL_STATUS, invoice.getStatus());
        }
        if(Objects.nonNull(invoice.getErrorMsg())){
            update.set(COL_ERROR_MSG, invoice.getErrorMsg());
        }
        if(Objects.nonNull(invoice.getInvoiceCode())){
            update.set(COL_INVOICE_CODE, invoice.getInvoiceCode());
        }
        if(Objects.nonNull(invoice.getInvoiceNo())){
            update.set(COL_INVOICE_NO, invoice.getInvoiceNo());
        }
        if(Objects.nonNull(invoice.getCheckCode())){
            update.set(COL_CHECK_CODE, invoice.getCheckCode());
        }
        if(Objects.nonNull(invoice.getInvoiceUrl())){
            update.set(COL_INVOICE_URL, invoice.getInvoiceUrl());
        }
        if(Objects.nonNull(invoice.getInvoiceApproveInfo())
            &&Objects.nonNull(invoice.getInvoiceApproveInfo().getOaRequestId())){
            update.set(COL_OA_REQUEST_ID, invoice.getInvoiceApproveInfo().getOaRequestId());
        }

        getMongoTemplate().updateFirst(query, update, Trade.class);
    }

    @Override
    public Boolean existsTrade(String orderNo) {
        return getMongoTemplate().exists(new Query(Criteria.where(COL_ORDER_NO).is(orderNo)), Trade.class);
    }

    @Override
    public Boolean existsItemId(String orderNo, String itemId) {
        Criteria criteria = Criteria.where(COL_ORDER_NO).is(orderNo);
        criteria.and(QUERY_INVOICE_ITEM_ID).is(itemId);
        return getMongoTemplate().exists(new Query(criteria), Trade.class);
    }

    @Override
    public List<InvoiceDO> findNotReversedBlueInvoice(RedBlueInvoiceCreateDTO redInvoiceCreateTrade) {
        List<AggregationOperation> aggregationOperationList = Lists.newArrayList();
        aggregationOperationList.add(Aggregation.unwind(MongoDbColumnConstants.COL_INVOICE_LIST));
        Criteria criteria = new Criteria();
        criteria.and(MongoDbColumnConstants.COL_SHOP_CODE).is(redInvoiceCreateTrade.getShopCode());
        criteria.and(MongoDbColumnConstants.COL_ORDER_NO).is(redInvoiceCreateTrade.getPfDocNo());
        criteria.and(MongoDbColumnConstants.QUERY_INVOICE_STATUS).ne(Constants.INVOICE_STATUS_CANCEL);
        criteria.and(MongoDbColumnConstants.QUERY_RED_OR_BLUE).is(Constants.INVOICE_BLUE);
        criteria.and(MongoDbColumnConstants.QUERY_IS_REVERSED).is(Constants.REVERSED_NO);
        aggregationOperationList.add(Aggregation.match(criteria));

        return aggregateList(aggregationOperationList, Trade.class, InvoiceDO.class);
    }

    @Override
    public List<InvoiceDO> findNeedReversedBlueInvoice(RedBlueInvoiceCreateDTO redInvoiceCreateTrade, Set<String> reversedSeriaNoSet) {
        List<AggregationOperation> aggregationOperationList = Lists.newArrayList();
        aggregationOperationList.add(Aggregation.unwind(MongoDbColumnConstants.COL_INVOICE_LIST));
        Criteria criteria = new Criteria();
        criteria.and(MongoDbColumnConstants.COL_SHOP_CODE).is(redInvoiceCreateTrade.getShopCode());
        criteria.and(MongoDbColumnConstants.COL_ORDER_NO).is(redInvoiceCreateTrade.getPfDocNo());
        criteria.and(MongoDbColumnConstants.QUERY_INVOICE_STATUS).ne(Constants.INVOICE_STATUS_CANCEL);
        criteria.and(MongoDbColumnConstants.QUERY_INVOICE_SERIA_NO).in(new ArrayList<>(reversedSeriaNoSet));
        criteria.and(MongoDbColumnConstants.QUERY_RED_OR_BLUE).is(Constants.INVOICE_BLUE);
        aggregationOperationList.add(Aggregation.match(criteria));

        return this.aggregateList(aggregationOperationList, Trade.class, InvoiceDO.class);
    }

    @Override
    public List<InvoiceDO> findNotIssuedElectronicInvoiceList(String shopCode, Integer size) {
        List<AggregationOperation> aggregationOperationList = Lists.newArrayList();
        aggregationOperationList.add(Aggregation.unwind(COL_INVOICE_LIST));
        Criteria criteria = new Criteria();
        criteria.and(COL_SHOP_CODE).is(shopCode);
        criteria.and(COL_INVOICE_CARRIER).is(Constants.INVOICE_CARRIER_ELECTRONIC);
        criteria.and(QUERY_INVOICE_STATUS).is(Constants.INVOICE_STATUS_NOT_SEND);
        aggregationOperationList.add(Aggregation.match(criteria));
        aggregationOperationList.add(Aggregation.skip(0L));
        aggregationOperationList.add(Aggregation.limit(size));

        return this.aggregateList(aggregationOperationList, Trade.class, InvoiceDO.class);
    }

    @Override
    public List<InvoiceDO> findInvoiceByOrderNoStatus(String shopCode, String orderNo, Integer status) {
        List<AggregationOperation> aggregationOperationList = new ArrayList<>();
        aggregationOperationList.add(Aggregation.unwind(COL_INVOICE_LIST));

        Criteria criteria = Criteria.where(COL_SHOP_CODE).is(shopCode);
        criteria.and(COL_ORDER_NO).is(orderNo);
        criteria.and(QUERY_INVOICE_STATUS).ne(status);
        criteria.and(QUERY_IS_REVERSED).is(Constants.REVERSED_NO);
        aggregationOperationList.add(Aggregation.match(criteria));

        return this.aggregateList(aggregationOperationList, Trade.class, InvoiceDO.class);
    }

    @Override
    public Integer findNotFinishedRedInvoiceCount(String shopCode, String orderNo) {
        Criteria criteria = Criteria.where(COL_SHOP_CODE).is(shopCode);
        criteria.and(COL_ORDER_NO).is(orderNo);
        criteria.and(QUERY_INVOICE_RED_OR_BLUE).is(Constants.INVOICE_RED);
        List<Integer> statusList = new ArrayList<>();
        statusList.add(Constants.INVOICE_STATUS_CREATE);
        statusList.add(Constants.INVOICE_STATUS_NOT_SEND);
        statusList.add(Constants.INVOICE_STATUS_SENDING);
        statusList.add(Constants.INVOICE_STATUS_FAIL);
        criteria.and(MongoDbColumnConstants.QUERY_INVOICE_STATUS).in(statusList);

        List<AggregationOperation> aggregationOperationList = Lists.newArrayList();
        aggregationOperationList.add(Aggregation.unwind(COL_INVOICE_LIST));
        aggregationOperationList.add(Aggregation.match(criteria));

        return aggregateCount(aggregationOperationList, Trade.class);
    }

    @Override
    public Long findFinishedBlueInvoice(String shopCode, String originalSeriaNo) {
        Criteria criteria = Criteria.where(COL_SHOP_CODE).is(shopCode);
        criteria.and(QUERY_INVOICE_RED_OR_BLUE).is(Constants.INVOICE_BLUE);
        criteria.and(QUERY_INVOICE_ORIGINAL_SERIA_NO).is(originalSeriaNo);
        criteria.and(QUERY_INVOICE_STATUS).is(Constants.INVOICE_STATUS_FINISHED);
        return getMongoTemplate().count(new Query(criteria), Trade.class);
    }

    @Override
    public String findSystemCodeBySeriaNo(String seriaNo) {
        BasicDBObject fieldsObject = new BasicDBObject();

        fieldsObject.put(COL_SYSTEM_CODE, true);

        DBObject queryObject = new BasicDBObject();
        queryObject.put(QUERY_INVOICE_SERIA_NO, seriaNo);

        Query query = new BasicQuery(queryObject, fieldsObject);

        Trade trade = this.getMongoTemplate().findOne(query, Trade.class);

        if(Objects.nonNull(trade)) {
            return trade.getSystemCode();
        }

        return null;
    }

    @Override
    public Trade findShopAndOrderBySeriaNo(String seriaNo) {
        BasicDBObject fieldsObject = new BasicDBObject();
        fieldsObject.put(COL_SHOP_CODE, true);
        fieldsObject.put(COL_ORDER_NO, true);

        DBObject queryObject = new BasicDBObject();
        queryObject.put(QUERY_INVOICE_SERIA_NO, seriaNo);

        Query query = new BasicQuery(queryObject, fieldsObject);

        return this.getMongoTemplate().findOne(query, Trade.class);
    }

    @Override
    public Trade findTradeByOrderNo(String orderNo) {
        return getMongoTemplate().findOne(new Query(Criteria.where(COL_ORDER_NO).is(orderNo)), Trade.class);
    }

    @Override
    public Pagination<InvoiceDO> queryInvoice(Page page, InvoiceQuery invoiceQuery) {
        List<AggregationOperation> aggregationOperationList = new ArrayList<>();
        aggregationOperationList.add(Aggregation.unwind(COL_INVOICE_LIST));
        aggregationOperationList.add(Aggregation.match(getCriteriaQueryInvoice(invoiceQuery)));

        return aggregatePage(page, aggregationOperationList, Trade.class, InvoiceDO.class);
    }

    @Override
    public List<InvoiceDO> findInvoiceByOrderNo(String orderNo) {
        List<AggregationOperation> aggregationOperationList = new ArrayList<>();
        aggregationOperationList.add(Aggregation.unwind(COL_INVOICE_LIST));
        aggregationOperationList.add(Aggregation.match(Criteria.where(COL_ORDER_NO).is(orderNo)));

        return  this.aggregateList(aggregationOperationList, Trade.class, InvoiceDO.class);
    }

    @Override
    public Pagination<InvoiceDO> queryInvoice(Page page, Sort[] sorts, InvoiceCommonQuery invoiceCommonQuery) {
        List<AggregationOperation> aggregationOperationList = new ArrayList<>();
        aggregationOperationList.add(Aggregation.unwind(COL_INVOICE_LIST));
        aggregationOperationList.add(Aggregation.match(getCommonQuery(invoiceCommonQuery)));

        aggregateSort(sorts, aggregationOperationList);

        return  this.aggregatePage(page, aggregationOperationList, Trade.class, InvoiceDO.class);
    }

    @Override
    public List<InvoiceDO> findInvoiceBySeriaNo(List<String> seriaNoList) {
        List<AggregationOperation> aggregationOperationList = new ArrayList<>();
        aggregationOperationList.add(Aggregation.unwind(COL_INVOICE_LIST));
        aggregationOperationList.add(Aggregation.match(Criteria.where(QUERY_INVOICE_SERIA_NO).in(seriaNoList)));

        return this.aggregateList(aggregationOperationList, Trade.class, InvoiceDO.class);
    }

    @Override
    public Boolean existsTrade(String orderNo, String seriaNo) {
        List<AggregationOperation> aggregationOperationList = new ArrayList<>();
        aggregationOperationList.add(Aggregation.unwind(COL_INVOICE_LIST));
        Criteria criteria = Criteria.where(COL_ORDER_NO).is(orderNo);
        criteria.and(QUERY_INVOICE_SERIA_NO).is(seriaNo);
        aggregationOperationList.add(Aggregation.match(criteria));

        int count = this.aggregateCount(aggregationOperationList, Trade.class);

        if(count>Constants.ZERO){
            return Boolean.TRUE;
        }else{
            return Boolean.FALSE;
        }
    }

    @Override
    public String findSeriaNo(Long oaRequestId) {
        List<AggregationOperation> aggregationOperationList = new ArrayList<>();
        aggregationOperationList.add(Aggregation.unwind(COL_INVOICE_LIST));
        Criteria criteria = Criteria.where(QUERY_OA_REQUEST_ID).is(oaRequestId);
        aggregationOperationList.add(Aggregation.match(criteria));
        InvoiceDO invoiceDO = this.aggregateOne(aggregationOperationList, Trade.class, InvoiceDO.class);
        if(Objects.nonNull(invoiceDO)&&Objects.nonNull(invoiceDO.getInvoiceList())){
            return invoiceDO.getInvoiceList().getSeriaNo();
        }else{
            return null;
        }
    }

    private Criteria getCommonQuery(InvoiceCommonQuery invoiceCommonQuery) {
        Criteria criteria = new Criteria();
        if(this.isNotEmpty(invoiceCommonQuery.getSeriaNo())){
            criteria.and(QUERY_INVOICE_SERIA_NO).is(invoiceCommonQuery.getSeriaNo());
        }
        if(this.isNotEmpty(invoiceCommonQuery.getOrderNo())){
            criteria.and(COL_ORDER_NO).is(invoiceCommonQuery.getOrderNo());
        }
        if(this.isNotEmpty(invoiceCommonQuery.getOrderDocNo())){
            criteria.and(COL_ORDER_DOC_NO).is(invoiceCommonQuery.getOrderDocNo());
        }
        if(this.isNotEmpty(invoiceCommonQuery.getInvoiceCarrier())){
            criteria.and(COL_INVOICE_CARRIER).is(invoiceCommonQuery.getInvoiceCarrier());
        }
        if(this.isNotEmpty(invoiceCommonQuery.getInvoiceType())){
            criteria.and(COL_INVOICE_TYPE).is(invoiceCommonQuery.getInvoiceType());
        }
        if(this.isNotEmpty(invoiceCommonQuery.getInvoiceTitleType())){
            criteria.and(QUERY_INVOICE_TITLE_TYPE).is(invoiceCommonQuery.getInvoiceTitleType());
        }
        if(this.isNotEmpty(invoiceCommonQuery.getInvoiceTitle())){
            criteria.and(QUERY_INVOICE_TITLE).is(invoiceCommonQuery.getInvoiceTitle());
        }
        if(this.isNotEmpty(invoiceCommonQuery.getRedOrBlue())){
            criteria.and(QUERY_RED_OR_BLUE).is(invoiceCommonQuery.getRedOrBlue());
        }
        if(this.isNotEmpty(invoiceCommonQuery.getIsReversed())){
            criteria.and(QUERY_IS_REVERSED).is(invoiceCommonQuery.getIsReversed());
        }
        if(this.isNotEmpty(invoiceCommonQuery.getTotalPrice())){
            Pattern pattern = Pattern.compile(String.format(Constants.PRICE_FORMAT, invoiceCommonQuery.getTotalPrice().toString()), Pattern.CASE_INSENSITIVE);
            criteria.and(QUERY_TOTAL_PRICE).regex(pattern);
        }
        if(this.isNotEmpty(invoiceCommonQuery.getTotalTax())){
            Pattern pattern = Pattern.compile(String.format(Constants.PRICE_FORMAT, invoiceCommonQuery.getTotalTax().toString()), Pattern.CASE_INSENSITIVE);
            criteria.and(QUERY_TOTAL_TAX).regex(pattern);
        }
        getDefaultQuery(invoiceCommonQuery, criteria);

        return criteria;
    }

    private void getDefaultQuery(InvoiceCommonQuery invoiceCommonQuery, Criteria criteria) {
        if(this.isNotEmpty(invoiceCommonQuery.getStatus())&&this.isNotEmpty(invoiceCommonQuery.getStatusList())){
            invoiceCommonQuery.getStatusList().add(invoiceCommonQuery.getStatus());
            criteria.and(QUERY_INVOICE_STATUS).in(invoiceCommonQuery.getStatusList());
        }else if(this.isNotEmpty(invoiceCommonQuery.getStatus())){
            criteria.and(QUERY_INVOICE_STATUS).is(invoiceCommonQuery.getStatus());
        }else if(this.isNotEmpty(invoiceCommonQuery.getStatusList())){
            criteria.and(QUERY_INVOICE_STATUS).in(invoiceCommonQuery.getStatusList());
        }
        if(this.isNotEmpty(invoiceCommonQuery.getApplyType())){
            criteria.and(QUERY_APPLY_TYPE).is(invoiceCommonQuery.getApplyType());
        }
        if(this.isNotEmpty(invoiceCommonQuery.getLastModifyLoginName())){
            criteria.and(QUERY_LAST_MODIFY_LOGIN_NAME).is(invoiceCommonQuery.getLastModifyLoginName());
        }
        if(this.isNotEmpty(invoiceCommonQuery.getLastModifyUserName())){
            criteria.and(QUERY_LAST_MODIFY_USER_NAME).is(invoiceCommonQuery.getLastModifyUserName());
        }
    }

    private Criteria getCriteriaQueryInvoice(InvoiceQuery invoiceQuery) {
        Criteria criteria = new Criteria();
        if(this.isNotEmpty(invoiceQuery.getShopCode())){
            criteria.and(COL_SHOP_CODE).is(invoiceQuery.getShopCode());
        }
        if(this.isNotEmpty(invoiceQuery.getOrderNo())){
            criteria.and(COL_ORDER_NO).is(invoiceQuery.getOrderNo());
        }
        if(this.isNotEmpty(invoiceQuery.getOrderDocNo())){
            criteria.and(COL_ORDER_DOC_NO).is(invoiceQuery.getOrderDocNo());
        }
        if(this.isNotEmpty(invoiceQuery.getSeriaNo())){
            criteria.and(QUERY_INVOICE_SERIA_NO).is(invoiceQuery.getSeriaNo());
        }
        if(this.isNotEmpty(invoiceQuery.getStatus())){
            criteria.and(QUERY_INVOICE_STATUS).is(invoiceQuery.getStatus());
        }
        if(this.isNotEmpty(invoiceQuery.getInvoiceType())){
            criteria.and(QUERY_INVOICE_TYPE).is(invoiceQuery.getInvoiceType());
        }
        if(this.isNotEmpty(invoiceQuery.getRedOrBlue())){
            criteria.and(QUERY_RED_OR_BLUE).is(invoiceQuery.getRedOrBlue());
        }
        if(this.isNotEmpty(invoiceQuery.getInvoiceTitleType())){
            criteria.and(QUERY_INVOICE_TITLE_TYPE).is(invoiceQuery.getInvoiceTitleType());
        }
        if(this.isNotEmpty(invoiceQuery.getInvoiceTitle())){
            criteria.and(QUERY_INVOICE_TITLE).is(invoiceQuery.getInvoiceTitle());
        }
        if(this.isNotEmpty(invoiceQuery.getIsReversed())){
            criteria.and(QUERY_IS_REVERSED).is(invoiceQuery.getIsReversed());
        }
        if(this.isNotEmpty(invoiceQuery.getTotal())){
            criteria.and(QUERY_TOTAL).is(invoiceQuery.getTotal());
        }
        if(this.isNotEmpty(invoiceQuery.getPayerMobile())){
            criteria.and(QUERY_PAYER_MOBILE).is(invoiceQuery.getPayerMobile());
        }
        if(this.isNotEmpty(invoiceQuery.getPayerEmail())){
            criteria.and(QUERY_PAYER_EMAIL).is(invoiceQuery.getPayerEmail());
        }
        return criteria;
    }

    private Update getUpdatePushInvoice(List<Invoice> invoiceList) {
        Update update = newUpdate();
        update.pushAll(COL_INVOICE_LIST, invoiceList.toArray());
        return update;
    }

    private Update newUpdate() {
        Update update = new Update();
        update.inc(COL_VERSION, 1);
        update.set(COL_LAST_MODIFY_TIME, new Date());
        return update;
    }

    private Update newUpdate(Trade trade) {
        Update update = new Update();
        update.inc(COL_VERSION, 1);
        update.set(COL_LAST_MODIFY_TIME, trade.getLastModifyTime());
        return update;
    }

}
三、写Junit UT
/**
 * 
 * @author Shuai Chen
 * 2019年1月10日   下午4:59:16
 *
 */
public class InvoiceDaoImplJunitTest extends BaseSpringBootTest{
    @Autowired
    private InvoiceDaoImpl invoiceDaoImpl;
    
    private Trade trade = TradeFactory.newInstance6();
    private Trade trade2 = TradeFactory.newInstance7();
    private Trade trade3 = TradeFactory.newInstance8();
    
    @Before
    public void init() {
        mongoTemplate.insert(trade);
        mongoTemplate.insert(trade2);
        mongoTemplate.insert(trade3);
    }
    
    @Test
    public void 根据平台订单号看订单是否存在dao_成功() {
        //given
        String orderNo = trade.getOrderNo();
        
        //when
        Boolean actual = invoiceDaoImpl.existsTrade(orderNo);
        
        //then
        assertTrue(actual);
    }
    
    @Test
    public void 根据平台订单号和订单航id看订单是否存在dao_成功() {
        //given
        String orderNo = trade.getOrderNo();
        String itemId = trade.getInvoiceList().iterator().next().getInvoiceLineList().iterator().next().getItemId();
        
        //when
        Boolean actual = invoiceDaoImpl.existsItemId(orderNo, itemId);
        
        //then
        assertTrue(actual);
    }
    
    @Test
    public void 查找未驳回蓝票dao_成功() {
        //given
        RedBlueInvoiceCreateDTO redInvoiceCreateTrade = new RedBlueInvoiceCreateDTO();
        redInvoiceCreateTrade.setShopCode(trade.getShopCode());
        redInvoiceCreateTrade.setPfDocNo(trade.getOrderNo());
        
        //when
        List<InvoiceDO> invoiceList = invoiceDaoImpl.findNotReversedBlueInvoice(redInvoiceCreateTrade);
        
        //then
        assertTrue(CollectionUtils.isNotEmpty(invoiceList));
    }
    
    @Test
    public void 查找需要驳回蓝票dao_成功() {
        //given
        RedBlueInvoiceCreateDTO redInvoiceCreateTrade = new RedBlueInvoiceCreateDTO();
        redInvoiceCreateTrade.setShopCode(trade.getShopCode());
        redInvoiceCreateTrade.setPfDocNo(trade.getOrderNo());
        
        String seriaNo = trade.getInvoiceList().iterator().next().getSeriaNo();
        Set<String> reversedSeriaNoSet = new HashSet<>(Arrays.asList(seriaNo));
        
        //when
        List<InvoiceDO> invoiceList = invoiceDaoImpl.findNeedReversedBlueInvoice(redInvoiceCreateTrade, reversedSeriaNoSet);
        
        //then
        assertTrue(CollectionUtils.isNotEmpty(invoiceList));
    }
    
    @Test
    public void 查找未发布电子发票dao_成功() {
        //given
        String shopCode = trade.getShopCode();
        Integer size = 9;

        //when
        List<InvoiceDO> invoiceList = invoiceDaoImpl.findNotIssuedElectronicInvoiceList(shopCode, size);
        
        //then
        assertTrue(CollectionUtils.isNotEmpty(invoiceList));
    }
    
    @Test
    public void 根据店铺编码A平台定单号A发票状态查找发票信息dao_成功(){
        //given
        String shopCode = trade.getShopCode();
        String orderNo = trade.getOrderNo();
        Integer status = Constants.INVOICE_STATUS_CANCEL;
        
        //when
        List<InvoiceDO> invoiceList = invoiceDaoImpl.findInvoiceByOrderNoStatus(shopCode, orderNo, status);
        
        //then
        assertTrue(CollectionUtils.isNotEmpty(invoiceList));
    }
    
    @Test
    public void 根据店铺编码和平台订单号查找未完成红票dao_成功(){
        //given
        String shopCode = trade2.getShopCode();
        String orderNo = trade2.getOrderNo();
        
        //when
        Integer actual = invoiceDaoImpl.findNotFinishedRedInvoiceCount(shopCode, orderNo);
        
        //then
        assertTrue(actual >= 1);
    }
    
    @Test
    public void 根据店铺编码和原发票代码查找完成的蓝票dao_成功() {
        //given
        String shopCode = trade3.getShopCode();
        String originalSeriaNo = trade3.getInvoiceList().iterator().next().getOriginalSeriaNo();
        
        //when
        Long actual = invoiceDaoImpl.findFinishedBlueInvoice(shopCode, originalSeriaNo);
        
        //then
        assertTrue(actual >= 1);
    }
    
    @Test
    public void 根据发票流水号查询系统编码dao_成功() {
        //given
        String seriaNo = trade.getInvoiceList().iterator().next().getSeriaNo();
        String expectedSystemCode = trade.getSystemCode();
        
        //when
        String actualSystemCode = invoiceDaoImpl.findSystemCodeBySeriaNo(seriaNo);
        
        //then
        assertEquals(expectedSystemCode, actualSystemCode);
    }
    
    @Test
    public void 根据发票流水号及其他合法参数查询订单dao_成功() {
        //given
        String seriaNo = trade.getInvoiceList().iterator().next().getSeriaNo();
        
        //when
        Trade actualTrade = invoiceDaoImpl.findShopAndOrderBySeriaNo(seriaNo);
        
        //then
        assertEquals(trade.getId(), actualTrade.getId());
    }
    
    @Test
    public void 根据发票流水号查询订单dao_成功() {
        //given
        String orderNo = trade.getOrderNo();
        
        //when
        Trade actualTrade = invoiceDaoImpl.findTradeByOrderNo(orderNo);
        
        //then
        assertEquals(trade.getId(), actualTrade.getId());
    }
    
    @Test
    public void 分页查询发票dao_成功() {
        //given
        Page page = new Page();
        InvoiceQuery invoiceQuery = InvoiceQueryFactory.newInstance1();
        
        //when
        Pagination<InvoiceDO> pageQuery = invoiceDaoImpl.queryInvoice(page, invoiceQuery);
        
        //then
        assertTrue(pageQuery.getItems().size() > 0);
    }
    
    @Test
    public void 根据发票流水号查询发票dao_成功() {
        //given
        String orderNo = trade.getOrderNo();
        
        //when
        List<InvoiceDO> invoiceList = invoiceDaoImpl.findInvoiceByOrderNo(orderNo);
        
        //then
        assertTrue(CollectionUtils.isNotEmpty(invoiceList));
    }
    
    //274行
    
    @After
    public void destory() {
        WriteResult wr = mongoTemplate.remove(Query.query(Criteria.where("_id").is(trade.getId())), Trade.class);
        assertTrue(1 == wr.getN());
        WriteResult wr2 = mongoTemplate.remove(Query.query(Criteria.where("_id").is(trade2.getId())), Trade.class);
        assertTrue(1 == wr2.getN());
        WriteResult wr3 = mongoTemplate.remove(Query.query(Criteria.where("_id").is(trade3.getId())), Trade.class);
        assertTrue(1 == wr3.getN());
    }
}
ShuaiLewis
关注
专栏目录
java中单元测试ut怎么写_合格的后端Coder都应该写好UT和Mock测试
weixin_30301989的博客
02-27 1817
关于测试测试都包括哪些广义的测试包括UT、IT、压力测试、硬件测试等等，这里重点讨论Unit Test即单元测试。啥是UT单元测试(又称为模块测试, Unit Testing)是针对程序模块(软件设计的最小单位)来进行正确性检验的测试工作。程序单元是应用的最小可测试部件。在过程化编程中，一个单元就是单个程序、函数、过程等；对于面向对象编程，最小单元就是方法，包括基类(超类)、抽象类、或者派生类(子...
java中单元测试ut怎么写_UT单元测试总结基础篇
weixin_33484711的博客
02-27 2258
最近需要在团队中引入单元测试实践，特地买了《单元测试的艺术》这本书来学习，在单元测试领域这本书写得相当好，非常系统和完善，对单元测试希望有一个更深入的认识的同学可以找来读一读。这篇文章对UT基础概念做了一个简单的总结，下一篇提高篇中再总结一下在Java项目中如何使用PowerMock和Mockito进行测试桩和模拟对象的创建，以规避测试时代码对外部模块的依赖问题。什么是单元测试一个单元测试是一段代...
如何写好单元测试
weixin_34163553的博客
09-04 1573
本文主要阐述单元测试（UT）的重要性，以及解释一些常见的困惑，以帮助我们写出质量更高的 UT。至于类似 Mocha 怎么用，断言库怎么用之类的问题，建议看官方文档。 原文在此 一、为什么需要写 UT 我发现很多朋友意识不到单元测试的重要性。在谈如何写好 UT 之前，我想先说说测试的必要性，这有利于提高我们写 UT 的内驱力。 假如，张三负责开发接口，李四负责开发具体的业务。李四会调用张三开发的接口...
JUnit-UT-and-TDD
06-25
关于这个回购 本系列练习和作业在 Java unsing Junit 中实现了社交网络应用程序的帐户相关 API。 API 由SocialNetwork类提供给用户。 业务逻辑主要在代表与用户或成员相关联的信息的较低级别类中： Account 。 您将修改和扩展此项目的类。 目标是： 练习单元测试。 应用基本的单元测试原则。 在实现新功能时练习 TDD。 在重构代码时练习 TDD。 在开发和更改软件时欣赏单元测试的价值。 单元测试和 TDD 练习 使用 [下载 ZIP] 链接下载存储库。 不要使用 [Clone in Desktop] 链接。 不要尝试将您的更改推送回此存储库。 将存储库导入您的 Eclipse 工作区。 按照给定的顺序完成任务。 单元测试热身练习：重构测试代码 查看给定的 Java 程序并重构测试代码 L1。 重命名命名不当的测试。 L2。 查找过度保护的
一个演示Junit4实现原理的ut
liangjing1000的专栏
01-29 354
文|码术张 本文旨在说明Junit4源代码的设计思想。 说明方式上，使用的是自己的一个创新的想法： 用一个ut来说明。 代码如下; package test; import org.junit.Test; public class IpTest { @Test public void should_True() throws Exception{ MyNotifier notifier = new MyNotifier(); MyResult resul
合格的后端Coder都应该写好UT和Mock测试
Newerwu的专栏
02-03 977
关于测试 测试都包括哪些 广义的测试包括UT、IT、压力测试、硬件测试等等，这里重点讨论Unit Test即单元测试。 啥是UT 单元测试（又称为模块测试, Unit Testing）是针对程序模块（软件设计的最小单位）来进行正确性检验的测试工作。程序单元是应用的最小可测试部件。在过程化编程中，一个单元就是单个程序、函数、过程等；对于面向对象编程，最小单元就是方法，包括基类（超类）、抽象类、或者派生类（子类）中的方法。 简而言之就是覆盖你的代码的一些测试用例，不依赖于任何第三方的服务依赖，如H
【JAVA-UT】2、写UT的科学步骤
liangjing1000的专栏
04-24 5777
本节演示如何写一个ut。 首先给出一个类Result。 public Class Result { private String downLoadStatus; private String failureReason; public Result(String status, String reason) { downLoadStatus= status; ...
写UT时的技巧总结
doinganddoing的专栏
07-12 361
用脚本去编译需要从头构建比较慢，在全量构建一次后可以直接在/zdrive/tests/这个目录下运行makefile，需要指定target编译完以后，可以找到自己的ut可执行文件直接运行，比如这样可以比较快的发现问题，当然也可以直接下断点。如果要查看覆盖率，需要把所有用例执行一遍，同样在这个目录下，覆盖率文件在zdrive\tests\platform\modules\om\coverage_report。
UT:epam tat + rpa
05-07
综上所述，"UT:epam tat + rpa" 可能是一个使用Java编程语言，涉及到Epam Systems的自动化测试技术和RPA实现的项目。项目的具体细节，如具体测试策略、RPA流程和实现方法，需要查看压缩包文件的具体内容才能进一步...
Python中unittest模块做UT（单元测试）使用实例
09-21
### Python中unittest模块做UT（单元测试）使用实例详解 #### 一、单元测试与unittest模块简介 单元测试(Unit Test)是一种软件开发过程中的测试方法，它针对软件中的最小可测试单元进行验证，通常指的是一个类或者...
写UT：使用Mock写UT
People of solitary
02-15 2302
以前喜欢说废话，废话少说，直接上代码。 一、测试类基类 @RunWith(MockitoJUnitRunner.class) public abstract class BaseMockTest { } 二、被测试类 举一个例子，代码如下，不需要看明白代码，只需要知道这是一个controller的类，manager,dao层的mock都如此测试即可。 package com.baozun.ec...
Spring与junit测试
为梦想而奋斗，无悔_一叶扁舟的点滴成长！
09-21 1407
1.我们知道无论在J2SE还是android中都有junit测试，利用junit能够帮助方便测试代码。在之前的博客中我也写了一些J2SE的一些junit测试例子，今天对于Spring中junit小小的讨论一下。 这个Spring测试需要的jar包：      spring-test-3.2.0.RELEASE.jar 2.Spring和Junit的关系图 左边的采用传统的方式，
Spring整合Junit单元测试
qq_40867650的博客
11-11 206
1.环境准备 1.1 创建业务接口实现类 /** * 客户的业务层接口 */ public interface ICustomerService { /** * 查询所有客户 * @return */ List<Customer> findAllCustomer(); /** * 保存客户 * @param customer */ void s...
使用JUnit&Ant生成UT报表
weixin_30509393的博客
02-02 111
1. JUnit Test Case测试类需要从TestCase类继承 2. Ant的配置文件如下，添加一个target用来run JUnit并生成报表 <project default="report" basedir="."> <target name="runtests"> <java fork="yes" classname="ju...
UT编写记录
danfu_wu的博客
05-19 3288
UT编写规则https://zhuanlan.zhihu.com/p/424117483 1、遵循AIR原则 A（automation，自动化）：单元测试应该是全自动执行的，并且非交互。 I （Independence，独立性）：单元测试用例之间决不能互相调用，也不能依赖执行的先后次序。 --------反例：method2需要依赖method1的执行，将执行结果作为method2的输入。 R（Repeatable，可重复）：单元测试是可以重复执行的，不能受到外界环境的影响。 2、结构 a、.
MATLAB中的ut(kk)=NaN,matlab编程问题求解
weixin_39992483的博客
03-21 452
该楼层疑似违规已被系统折叠隐藏此楼查看此楼最近在学习极限学习机，在网站上下载了matlab代码，运行时出现了问题：未定义与 'struct' 类型的输入参数相对应的函数laplacian求大神能帮忙看看下面是代码format compact;clear;addpath(genpath('functions'))% load datatrial=1;load g50c;l=size(idxLabs...
一文学会gtest UT测试编写(TEST\TEST_F)
最新发布
weixin_36389889的博客
02-06 1342
手把手教你学会gtest写UT测试
java 编写ut积累
jiaweizhong的博客
11-14 530
编写ut积累 通过反射的方法获取类中私有变量属性值 1、Class clazz = 类名.class 2、Field field = clazz.getDeclaredField(“变量名”) // 获取类中所有变量，包括public ,private,protected, 通过getField()方法只能访问public的变量。 3、field.setAccessible(true) 设置使能，使之可访问。 4、变量类型 变量名 = （变量类型） field.get(类实例对象) //在类实例
java：单元测试（UT）
m0_43514502的博客
11-05 5629
原则 1、分析需求场景 2、依据场景列出判断分支 3、依据分支编写测试用例，若方法具有多层调用，则依据逻辑，判断入参变化点，针对具有入参变化点的方法编写UT 4、编写实现逻辑 框架 本次使用Junit进行测试，基于Junit的模拟框架使用mockito配合powermock Junit：每个测试都是一个方法，比较输入输出以实现代码验证 TestNG：测试被组织的类，与Junit相同，但是要运行Te...
写UT
06-02
import org.junit.After; import org.junit.Before; import org.junit.Test; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.List; import static org.junit....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值