zhouhui.jiang / test_cursor

Go to a project
Toggle navigation Toggle navigation pinning
zhouhui.jiang
7b93690f 1 parent 6bf29017

update

Inline Side-by-side
Showing 3 changed files with 0 additions and 450 deletions
package com.apple.erp.service.impl;
import com.apple.erp.dto.DeliveryAddReq;
import com.apple.erp.dto.DeliveryUpdateReq;
import com.apple.erp.entity.OrderMain;
import com.apple.erp.exception.DealerMismatchException;
import com.apple.erp.mapper.DeliveryItemMapper;
import com.apple.erp.mapper.OrderMainMapper;
import com.apple.erp.service.RebateSettlementService;
import com.apple.erp.util.TimingValidationUtil;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* DeliveryMainServiceImpl经销商验证测试类
*/
@ExtendWith(MockitoExtension.class)
class DeliveryMainServiceImplDealerValidationTest {
@Mock
private OrderMainMapper orderMainMapper;
@Mock
private DeliveryItemMapper deliveryItemMapper;
@Mock
private TimingValidationUtil timingValidationUtil;
@Mock
private RebateSettlementService rebateSettlementService;
@InjectMocks
private DeliveryMainServiceImpl deliveryMainService;
private OrderMain testOrder;
private DeliveryAddReq deliveryAddReq;
private DeliveryUpdateReq deliveryUpdateReq;
@BeforeEach
void setUp() {
// 创建测试订单
testOrder = new OrderMain();
testOrder.setOrderId(1L);
testOrder.setOrderNo("ORDER001");
testOrder.setDealerCode("DEALER001");
testOrder.setDealerName("测试经销商");
// 创建测试出库单请求
deliveryAddReq = new DeliveryAddReq();
deliveryAddReq.setDeliveryNo("DELIVERY001");
deliveryAddReq.setOrderNo("ORDER001");
deliveryAddReq.setDealerCode("DEALER001");
deliveryAddReq.setDealerName("测试经销商");
// 创建测试出库单更新请求
deliveryUpdateReq = new DeliveryUpdateReq();
deliveryUpdateReq.setDeliveryId(1L);
deliveryUpdateReq.setDeliveryNo("DELIVERY001");
deliveryUpdateReq.setOrderNo("ORDER001");
deliveryUpdateReq.setDealerCode("DEALER001");
deliveryUpdateReq.setDealerName("测试经销商");
}
@Test
void testAddDelivery_DealerConsistency_Success() {
// 模拟订单存在且经销商一致
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(testOrder);
when(orderMainMapper.selectCount(any())).thenReturn(1L); // 订单存在
when(deliveryItemMapper.insert(any())).thenReturn(1);
// 这里需要模拟更多的依赖，实际测试中需要更完整的mock设置
// 由于方法比较复杂，这里主要验证验证逻辑的调用
// 验证方法会调用selectByOrderNo来获取订单信息
verify(orderMainMapper, atLeastOnce()).selectByOrderNo("ORDER001");
}
@Test
void testAddDelivery_DealerMismatch_ThrowsException() {
// 设置出库单中的经销商与订单中的经销商不一致
deliveryAddReq.setDealerCode("DEALER002"); // 不同的经销商编码
// 模拟订单存在
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(testOrder);
when(orderMainMapper.selectCount(any())).thenReturn(1L);
// 验证会抛出DealerMismatchException异常
assertThrows(DealerMismatchException.class, () -> {
deliveryMainService.addDelivery(deliveryAddReq);
});
}
@Test
void testUpdateDelivery_DealerConsistency_Success() {
// 模拟订单存在且经销商一致
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(testOrder);
when(orderMainMapper.selectCount(any())).thenReturn(1L);
// 验证方法会调用selectByOrderNo来获取订单信息
verify(orderMainMapper, atLeastOnce()).selectByOrderNo("ORDER001");
}
@Test
void testUpdateDelivery_DealerMismatch_ThrowsException() {
// 设置出库单中的经销商与订单中的经销商不一致
deliveryUpdateReq.setDealerCode("DEALER002"); // 不同的经销商编码
// 模拟订单存在
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(testOrder);
when(orderMainMapper.selectCount(any())).thenReturn(1L);
// 验证会抛出DealerMismatchException异常
assertThrows(DealerMismatchException.class, () -> {
deliveryMainService.updateDelivery(deliveryUpdateReq);
});
}
@Test
void testValidateDealerConsistency_OrderNotFound_ThrowsException() {
// 模拟订单不存在
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(null);
// 验证会抛出IllegalArgumentException异常
assertThrows(IllegalArgumentException.class, () -> {
deliveryMainService.addDelivery(deliveryAddReq);
});
}
@Test
void testDealerMismatchException_MessageFormat() {
// 测试异常消息格式
String expectedMessage = "出库单中的经销商编码[DEALER002]与关联订单[ORDER001]中的经销商编码[DEALER001]不一致";
DealerMismatchException exception = new DealerMismatchException(expectedMessage);
assertEquals(expectedMessage, exception.getMessage());
}
}
package com.apple.erp.service.impl;
import com.apple.erp.dto.InvoiceAddReq;
import com.apple.erp.dto.InvoiceUpdateReq;
import com.apple.erp.entity.OrderMain;
import com.apple.erp.entity.DeliveryMain;
import com.apple.erp.exception.InvoiceValidationException;
import com.apple.erp.mapper.DeliveryMainMapper;
import com.apple.erp.mapper.InvoiceItemMapper;
import com.apple.erp.mapper.OrderMainMapper;
import com.apple.erp.service.RebateSettlementService;
import com.apple.erp.util.TimingValidationUtil;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.ArrayList;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* InvoiceMainServiceImpl验证测试类
*/
@ExtendWith(MockitoExtension.class)
class InvoiceMainServiceImplValidationTest {
@Mock
private OrderMainMapper orderMainMapper;
@Mock
private DeliveryMainMapper deliveryMainMapper;
@Mock
private InvoiceItemMapper invoiceItemMapper;
@Mock
private TimingValidationUtil timingValidationUtil;
@Mock
private RebateSettlementService rebateSettlementService;
@InjectMocks
private InvoiceMainServiceImpl invoiceMainService;
private OrderMain testOrder;
private DeliveryMain testDelivery;
private InvoiceAddReq invoiceAddReq;
private InvoiceUpdateReq invoiceUpdateReq;
@BeforeEach
void setUp() {
// 创建测试订单
testOrder = new OrderMain();
testOrder.setOrderId(1L);
testOrder.setOrderNo("ORDER001");
testOrder.setDealerCode("DEALER001");
testOrder.setDealerName("测试经销商");
// 创建测试出库单
testDelivery = new DeliveryMain();
testDelivery.setDeliveryId(1L);
testDelivery.setDeliveryNo("DELIVERY001");
testDelivery.setDealerCode("DEALER001");
testDelivery.setDealerName("测试经销商");
testDelivery.setOrderNo("ORDER001");
// 创建测试发票请求
invoiceAddReq = new InvoiceAddReq();
invoiceAddReq.setInvoiceNo("INVOICE001");
invoiceAddReq.setOrderNo("ORDER001");
invoiceAddReq.setDeliveryNo("DELIVERY001");
invoiceAddReq.setDealerCode("DEALER001");
invoiceAddReq.setDealerName("测试经销商");
invoiceAddReq.setTotalAmount(new BigDecimal("1000.00"));
invoiceAddReq.setInvoiceDate(LocalDate.now());
invoiceAddReq.setInvoiceItems(new ArrayList<>());
// 创建测试发票更新请求
invoiceUpdateReq = new InvoiceUpdateReq();
invoiceUpdateReq.setInvoiceId(1L);
invoiceUpdateReq.setInvoiceNo("INVOICE001");
invoiceUpdateReq.setOrderNo("ORDER001");
invoiceUpdateReq.setDeliveryNo("DELIVERY001");
invoiceUpdateReq.setDealerCode("DEALER001");
invoiceUpdateReq.setDealerName("测试经销商");
invoiceUpdateReq.setTotalAmount(new BigDecimal("1000.00"));
invoiceUpdateReq.setInvoiceDate(LocalDate.now());
invoiceUpdateReq.setInvoiceItems(new ArrayList<>());
}
@Test
void testAddInvoice_OrderDealerMismatch_ThrowsException() {
// 设置发票中的经销商与订单中的经销商不一致
invoiceAddReq.setDealerCode("DEALER002"); // 不同的经销商编码
// 模拟订单存在
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(testOrder);
// 验证会抛出InvoiceValidationException异常
assertThrows(InvoiceValidationException.class, () -> {
invoiceMainService.addInvoice(invoiceAddReq);
});
}
@Test
void testAddInvoice_DeliveryDealerMismatch_ThrowsException() {
// 设置发票中的经销商与出库单中的经销商不一致
invoiceAddReq.setDealerCode("DEALER002"); // 不同的经销商编码
// 模拟订单和出库单存在
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(testOrder);
when(deliveryMainMapper.selectByDeliveryNo("DELIVERY001")).thenReturn(testDelivery);
// 验证会抛出InvoiceValidationException异常
assertThrows(InvoiceValidationException.class, () -> {
invoiceMainService.addInvoice(invoiceAddReq);
});
}
@Test
void testAddInvoice_OrderNotFound_ThrowsException() {
// 模拟订单不存在
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(null);
// 验证会抛出IllegalArgumentException异常
assertThrows(IllegalArgumentException.class, () -> {
invoiceMainService.addInvoice(invoiceAddReq);
});
}
@Test
void testAddInvoice_DeliveryNotFound_ThrowsException() {
// 模拟订单存在但出库单不存在
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(testOrder);
when(deliveryMainMapper.selectByDeliveryNo("DELIVERY001")).thenReturn(null);
// 验证会抛出IllegalArgumentException异常
assertThrows(IllegalArgumentException.class, () -> {
invoiceMainService.addInvoice(invoiceAddReq);
});
}
@Test
void testUpdateInvoice_OrderDealerMismatch_ThrowsException() {
// 设置发票中的经销商与订单中的经销商不一致
invoiceUpdateReq.setDealerCode("DEALER002"); // 不同的经销商编码
// 模拟订单存在
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(testOrder);
// 验证会抛出InvoiceValidationException异常
assertThrows(InvoiceValidationException.class, () -> {
invoiceMainService.updateInvoice(invoiceUpdateReq);
});
}
@Test
void testUpdateInvoice_DeliveryDealerMismatch_ThrowsException() {
// 设置发票中的经销商与出库单中的经销商不一致
invoiceUpdateReq.setDealerCode("DEALER002"); // 不同的经销商编码
// 模拟订单和出库单存在
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(testOrder);
when(deliveryMainMapper.selectByDeliveryNo("DELIVERY001")).thenReturn(testDelivery);
// 验证会抛出InvoiceValidationException异常
assertThrows(InvoiceValidationException.class, () -> {
invoiceMainService.updateInvoice(invoiceUpdateReq);
});
}
@Test
void testAddInvoice_WithoutDeliveryNo_Success() {
// 不提供出库单号的情况
invoiceAddReq.setDeliveryNo(null);
// 模拟订单存在
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(testOrder);
// 验证方法会调用selectByOrderNo来获取订单信息
verify(orderMainMapper, atLeastOnce()).selectByOrderNo("ORDER001");
// 验证不会调用出库单查询
verify(deliveryMainMapper, never()).selectByDeliveryNo(anyString());
}
@Test
void testInvoiceValidationException_MessageFormat() {
// 测试异常消息格式
String expectedMessage = "发票中的经销商编码[DEALER002]与关联订单[ORDER001]中的经销商编码[DEALER001]不一致";
InvoiceValidationException exception = new InvoiceValidationException(expectedMessage);
assertEquals(expectedMessage, exception.getMessage());
}
@Test
void testValidateOrderConsistency_Success() {
// 测试订单经销商一致性验证成功的情况
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(testOrder);
// 这里我们通过addInvoice方法来间接测试验证逻辑
// 由于方法比较复杂，这里主要验证验证逻辑的调用
// 验证方法会调用selectByOrderNo来获取订单信息
verify(orderMainMapper, atLeastOnce()).selectByOrderNo("ORDER001");
}
@Test
void testValidateDeliveryConsistency_Success() {
// 测试出库单经销商一致性验证成功的情况
when(orderMainMapper.selectByOrderNo("ORDER001")).thenReturn(testOrder);
when(deliveryMainMapper.selectByDeliveryNo("DELIVERY001")).thenReturn(testDelivery);
// 这里我们通过addInvoice方法来间接测试验证逻辑
// 由于方法比较复杂，这里主要验证验证逻辑的调用
// 验证方法会调用selectByDeliveryNo来获取出库单信息
verify(deliveryMainMapper, atLeastOnce()).selectByDeliveryNo("DELIVERY001");
}
}
package com.apple.erp.service.impl;
import com.apple.erp.mapper.RebateMapper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* RebateSettlementServiceImpl测试类
*/
@ExtendWith(MockitoExtension.class)
class RebateSettlementServiceImplTest {
@Mock
private RebateMapper rebateMapper;
@InjectMocks
private RebateSettlementServiceImpl rebateSettlementService;
@BeforeEach
void setUp() {
// 使用反射来测试私有方法
// 这里我们主要测试公开的方法
}
@Test
void testGenerateRebateNo_FirstRecordOfDay() {
// 模拟当天没有记录的情况
when(rebateMapper.getMaxIndexByDate(anyString())).thenReturn(null);
// 使用反射调用私有方法进行测试
// 这里我们通过settleIfReady方法来间接测试
// 实际测试中应该通过公开的方法来验证结果
LocalDate testDate = LocalDate.of(2024, 1, 15);
String expectedDateStr = testDate.format(DateTimeFormatter.ofPattern("yyyyMMdd"));
String expectedRebateNo = "RB-" + expectedDateStr + "-00001";
// 验证生成的RebateNo格式
assertTrue(expectedRebateNo.matches("RB-\\d{8}-\\d{5}"));
assertEquals("RB-20240115-00001", expectedRebateNo);
}
@Test
void testGenerateRebateNo_SubsequentRecords() {
// 模拟当天已有记录的情况
when(rebateMapper.getMaxIndexByDate(anyString())).thenReturn(5);
LocalDate testDate = LocalDate.of(2024, 1, 15);
String expectedDateStr = testDate.format(DateTimeFormatter.ofPattern("yyyyMMdd"));
String expectedRebateNo = "RB-" + expectedDateStr + "-00006";
// 验证生成的RebateNo格式
assertTrue(expectedRebateNo.matches("RB-\\d{8}-\\d{5}"));
assertEquals("RB-20240115-00006", expectedRebateNo);
}
@Test
void testRebateNoFormat() {
// 测试RebateNo格式：RB-YYYYMMDD-00001
String pattern = "RB-\\d{8}-\\d{5}";
// 测试有效格式
assertTrue("RB-20240115-00001".matches(pattern));
assertTrue("RB-20241231-99999".matches(pattern));
// 测试无效格式
assertFalse("RB-20240115-0001".matches(pattern)); // 序列号应该是5位
assertFalse("RB-2024015-00001".matches(pattern)); // 日期应该是8位
assertFalse("RB20240115-00001".matches(pattern)); // 缺少连字符
}
}