package cn.iocoder.yudao.module.trade.service.price.calculator;
|
|
import cn.hutool.core.map.MapUtil;
|
import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum;
|
import cn.iocoder.yudao.framework.test.core.ut.BaseMockitoUnitTest;
|
import cn.iocoder.yudao.module.member.api.address.MemberAddressApi;
|
import cn.iocoder.yudao.module.member.api.address.dto.MemberAddressRespDTO;
|
import cn.iocoder.yudao.module.trade.dal.dataobject.config.TradeConfigDO;
|
import cn.iocoder.yudao.module.trade.dal.dataobject.delivery.DeliveryPickUpStoreDO;
|
import cn.iocoder.yudao.module.trade.enums.delivery.DeliveryExpressChargeModeEnum;
|
import cn.iocoder.yudao.module.trade.enums.delivery.DeliveryTypeEnum;
|
import cn.iocoder.yudao.module.trade.service.config.TradeConfigService;
|
import cn.iocoder.yudao.module.trade.service.delivery.DeliveryExpressTemplateService;
|
import cn.iocoder.yudao.module.trade.service.delivery.DeliveryPickUpStoreService;
|
import cn.iocoder.yudao.module.trade.service.delivery.bo.DeliveryExpressTemplateRespBO;
|
import cn.iocoder.yudao.module.trade.service.price.bo.TradePriceCalculateReqBO;
|
import cn.iocoder.yudao.module.trade.service.price.bo.TradePriceCalculateRespBO;
|
import org.junit.jupiter.api.BeforeEach;
|
import org.junit.jupiter.api.DisplayName;
|
import org.junit.jupiter.api.Test;
|
import org.mockito.InjectMocks;
|
import org.mockito.Mock;
|
|
import java.util.ArrayList;
|
import java.util.Collections;
|
|
import static cn.iocoder.yudao.framework.common.util.collection.SetUtils.asSet;
|
import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.assertServiceException;
|
import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.randomPojo;
|
import static cn.iocoder.yudao.module.trade.enums.ErrorCodeConstants.PICK_UP_STORE_NOT_EXISTS;
|
import static cn.iocoder.yudao.module.trade.enums.ErrorCodeConstants.PRICE_CALCULATE_DELIVERY_PRICE_TEMPLATE_NOT_FOUND;
|
import static cn.iocoder.yudao.module.trade.enums.ErrorCodeConstants.PRICE_CALCULATE_DELIVERY_PRICE_TYPE_ILLEGAL;
|
import static java.util.Arrays.asList;
|
import static java.util.Collections.singletonList;
|
import static org.assertj.core.api.Assertions.assertThat;
|
import static org.mockito.ArgumentMatchers.eq;
|
import static org.mockito.Mockito.when;
|
|
/**
|
* {@link TradeDeliveryPriceCalculator} 的单元测试
|
*
|
* @author jason
|
*/
|
public class TradeDeliveryPriceCalculatorTest extends BaseMockitoUnitTest {
|
|
@InjectMocks
|
private TradeDeliveryPriceCalculator calculator;
|
|
@Mock
|
private MemberAddressApi addressApi;
|
@Mock
|
private DeliveryPickUpStoreService deliveryPickUpStoreService;
|
@Mock
|
private DeliveryExpressTemplateService deliveryExpressTemplateService;
|
@Mock
|
private TradeConfigService tradeConfigService;
|
|
private TradePriceCalculateReqBO reqBO;
|
private TradePriceCalculateRespBO resultBO;
|
|
private DeliveryExpressTemplateRespBO templateRespBO;
|
private DeliveryExpressTemplateRespBO.Charge chargeBO;
|
private DeliveryExpressTemplateRespBO.Free freeBO;
|
|
@BeforeEach
|
public void init() {
|
// 准备参数
|
reqBO = new TradePriceCalculateReqBO()
|
.setDeliveryType(DeliveryTypeEnum.EXPRESS.getType())
|
.setAddressId(10L)
|
.setUserId(1L)
|
.setItems(asList(
|
new TradePriceCalculateReqBO.Item().setSkuId(10L).setCount(2).setSelected(true),
|
new TradePriceCalculateReqBO.Item().setSkuId(20L).setCount(10).setSelected(true),
|
new TradePriceCalculateReqBO.Item().setSkuId(30L).setCount(4).setSelected(false) // 未选中
|
));
|
resultBO = new TradePriceCalculateRespBO()
|
.setPrice(new TradePriceCalculateRespBO.Price())
|
.setPromotions(new ArrayList<>())
|
.setItems(asList(
|
new TradePriceCalculateRespBO.OrderItem().setDeliveryTemplateId(1L).setSkuId(10L).setCount(2).setSelected(true)
|
.setWeight(10d).setVolume(10d).setPrice(100)
|
.setDeliveryTypes(asList(DeliveryTypeEnum.EXPRESS.getType(), DeliveryTypeEnum.PICK_UP.getType())),
|
new TradePriceCalculateRespBO.OrderItem().setDeliveryTemplateId(1L).setSkuId(20L).setCount(10).setSelected(true)
|
.setWeight(10d).setVolume(10d).setPrice(200)
|
.setDeliveryTypes(asList(DeliveryTypeEnum.EXPRESS.getType(), DeliveryTypeEnum.PICK_UP.getType())),
|
new TradePriceCalculateRespBO.OrderItem().setDeliveryTemplateId(1L).setSkuId(30L).setCount(1).setSelected(false)
|
.setWeight(10d).setVolume(10d).setPrice(300)
|
.setDeliveryTypes(asList(DeliveryTypeEnum.EXPRESS.getType(), DeliveryTypeEnum.PICK_UP.getType()))
|
));
|
// 保证价格被初始化上
|
TradePriceCalculatorHelper.recountPayPrice(resultBO.getItems());
|
TradePriceCalculatorHelper.recountAllPrice(resultBO);
|
|
// 准备运费模板费用配置数据：起步 10 件 1000 分，续 10 件 2000 分
|
chargeBO = randomPojo(DeliveryExpressTemplateRespBO.Charge.class,
|
item -> item.setStartCount(10D).setStartPrice(1000).setExtraCount(10D).setExtraPrice(2000));
|
// 准备运费模板包邮配置数据：默认不包邮（订单总件数 12 不大于 包邮件数 20）
|
freeBO = randomPojo(DeliveryExpressTemplateRespBO.Free.class,
|
item -> item.setFreeCount(20).setFreePrice(100));
|
// 准备 SP 运费模板数据
|
templateRespBO = randomPojo(DeliveryExpressTemplateRespBO.class,
|
item -> item.setChargeMode(DeliveryExpressChargeModeEnum.COUNT.getType())
|
.setCharge(chargeBO).setFree(freeBO));
|
}
|
|
// ========== 配送方式校验 ==========
|
|
@Test
|
@DisplayName("配送方式为空：直接返回，不计算运费")
|
public void testCalculate_deliveryTypeNull() {
|
// 准备参数
|
reqBO.setDeliveryType(null);
|
|
// 调用
|
calculator.calculate(reqBO, resultBO);
|
|
// 断言：未计算运费
|
assertThat(resultBO.getPrice().getDeliveryPrice()).isEqualTo(0);
|
}
|
|
@Test
|
@DisplayName("配送方式与商品不匹配：抛出异常")
|
public void testCalculate_deliveryTypeMismatch() {
|
// 准备参数：商品 deliveryTypes 不包含 EXPRESS
|
resultBO.getItems().forEach(item -> item.setDeliveryTypes(singletonList(DeliveryTypeEnum.PICK_UP.getType())));
|
|
// 调用并断言异常
|
assertServiceException(() -> calculator.calculate(reqBO, resultBO),
|
PRICE_CALCULATE_DELIVERY_PRICE_TYPE_ILLEGAL);
|
}
|
|
// ========== 自提模式 ==========
|
|
@Test
|
@DisplayName("自提：未选择门店时直接返回")
|
public void testCalculate_pickUp_storeIdNull() {
|
// 准备参数
|
reqBO.setDeliveryType(DeliveryTypeEnum.PICK_UP.getType()).setPickUpStoreId(null);
|
|
// 调用
|
calculator.calculate(reqBO, resultBO);
|
|
// 断言：未计算运费
|
assertThat(resultBO.getPrice().getDeliveryPrice()).isEqualTo(0);
|
}
|
|
@Test
|
@DisplayName("自提：门店不存在时抛出异常")
|
public void testCalculate_pickUp_storeNotFound() {
|
// 准备参数
|
reqBO.setDeliveryType(DeliveryTypeEnum.PICK_UP.getType()).setPickUpStoreId(99L);
|
// mock：门店不存在
|
when(deliveryPickUpStoreService.getDeliveryPickUpStore(eq(99L))).thenReturn(null);
|
|
// 调用并断言异常
|
assertServiceException(() -> calculator.calculate(reqBO, resultBO),
|
PICK_UP_STORE_NOT_EXISTS);
|
}
|
|
@Test
|
@DisplayName("自提：门店被禁用时抛出异常")
|
public void testCalculate_pickUp_storeDisabled() {
|
// 准备参数
|
reqBO.setDeliveryType(DeliveryTypeEnum.PICK_UP.getType()).setPickUpStoreId(99L);
|
// mock：门店被禁用
|
when(deliveryPickUpStoreService.getDeliveryPickUpStore(eq(99L))).thenReturn(
|
new DeliveryPickUpStoreDO().setStatus(CommonStatusEnum.DISABLE.getStatus()));
|
|
// 调用并断言异常
|
assertServiceException(() -> calculator.calculate(reqBO, resultBO),
|
PICK_UP_STORE_NOT_EXISTS);
|
}
|
|
@Test
|
@DisplayName("自提：门店正常时不计算运费")
|
public void testCalculate_pickUp_ok() {
|
// 准备参数
|
reqBO.setDeliveryType(DeliveryTypeEnum.PICK_UP.getType()).setPickUpStoreId(99L);
|
// mock：门店正常
|
when(deliveryPickUpStoreService.getDeliveryPickUpStore(eq(99L))).thenReturn(
|
new DeliveryPickUpStoreDO().setStatus(CommonStatusEnum.ENABLE.getStatus()));
|
|
// 调用
|
calculator.calculate(reqBO, resultBO);
|
|
// 断言：未计算运费
|
assertThat(resultBO.getPrice().getDeliveryPrice()).isEqualTo(0);
|
}
|
|
// ========== 快递模式 ==========
|
|
@Test
|
@DisplayName("快递：收件地址为空时直接返回")
|
public void testCalculate_express_addressIdNull() {
|
// 准备参数
|
reqBO.setAddressId(null);
|
|
// 调用
|
calculator.calculate(reqBO, resultBO);
|
|
// 断言：未计算运费
|
assertThat(resultBO.getPrice().getDeliveryPrice()).isEqualTo(0);
|
}
|
|
@Test
|
@DisplayName("快递：全场包邮（开关开启 && 总金额满足全场包邮金额）")
|
public void testCalculate_globalFree() {
|
// mock：收件地址 + 全场包邮配置
|
mockAddress();
|
when(tradeConfigService.getTradeConfig()).thenReturn(new TradeConfigDO()
|
.setDeliveryExpressFreeEnabled(true).setDeliveryExpressFreePrice(2200));
|
|
// 调用
|
calculator.calculate(reqBO, resultBO);
|
|
// 断言
|
TradePriceCalculateRespBO.Price price = resultBO.getPrice();
|
assertThat(price)
|
.extracting("totalPrice", "discountPrice", "couponPrice", "pointPrice", "deliveryPrice", "payPrice")
|
.containsExactly(2200, 0, 0, 0, 0, 2200);
|
assertThat(resultBO.getItems()).hasSize(3);
|
assertThat(resultBO.getItems().get(0))
|
.extracting("price", "count", "discountPrice", "couponPrice", "pointPrice", "deliveryPrice", "payPrice")
|
.containsExactly(100, 2, 0, 0, 0, 0, 200);
|
assertThat(resultBO.getItems().get(1))
|
.extracting("price", "count", "discountPrice", "couponPrice", "pointPrice", "deliveryPrice", "payPrice")
|
.containsExactly(200, 10, 0, 0, 0, 0, 2000);
|
assertThat(resultBO.getItems().get(2))
|
.extracting("price", "count", "discountPrice", "couponPrice", "pointPrice", "deliveryPrice", "payPrice")
|
.containsExactly(300, 1, 0, 0, 0, 0, 300);
|
}
|
|
@Test
|
@DisplayName("快递：活动包邮（freeDelivery=true）时不计算运费")
|
public void testCalculate_activityFree() {
|
// 准备参数
|
resultBO.setFreeDelivery(true);
|
// mock：收件地址
|
mockAddress();
|
|
// 调用
|
calculator.calculate(reqBO, resultBO);
|
|
// 断言：未计算运费
|
assertThat(resultBO.getPrice().getDeliveryPrice()).isEqualTo(0);
|
}
|
|
@Test
|
@DisplayName("快递：找不到运费模板时抛出异常")
|
public void testCalculate_express_templateNotFound() {
|
// mock：收件地址 + 空模板
|
mockAddress();
|
when(deliveryExpressTemplateService.getExpressTemplateMapByIdsAndArea(eq(asSet(1L)), eq(10)))
|
.thenReturn(Collections.emptyMap());
|
|
// 调用并断言异常
|
assertServiceException(() -> calculator.calculate(reqBO, resultBO),
|
PRICE_CALCULATE_DELIVERY_PRICE_TEMPLATE_NOT_FOUND);
|
}
|
|
@Test
|
@DisplayName("按件计算运费：不包邮的情况")
|
public void testCalculate_expressTemplateCharge() {
|
// SKU 1：100 * 2 = 200
|
// SKU 2：200 * 10 = 2000
|
// 运费：首件 1000 + 续件 ceil((12-10)/10)=1 倍 * 2000 = 3000
|
// mock 方法：默认 freeCount=20，订单 12 件 不大于 20，不包邮
|
mockAddress();
|
mockTemplate(templateRespBO);
|
|
// 调用
|
calculator.calculate(reqBO, resultBO);
|
|
// 断言
|
TradePriceCalculateRespBO.Price price = resultBO.getPrice();
|
assertThat(price)
|
.extracting("totalPrice", "discountPrice", "couponPrice", "pointPrice", "deliveryPrice", "payPrice")
|
.containsExactly(2200, 0, 0, 0, 3000, 5200);
|
assertThat(resultBO.getItems()).hasSize(3);
|
// 断言：SKU1 分摊运费 (int)(3000 * 2/12) = 500
|
assertThat(resultBO.getItems().get(0))
|
.extracting("price", "count", "discountPrice", "couponPrice", "pointPrice", "deliveryPrice", "payPrice")
|
.containsExactly(100, 2, 0, 0, 0, 500, 700);
|
// 断言：SKU2 分摊运费 3000 - 500 = 2500
|
assertThat(resultBO.getItems().get(1))
|
.extracting("price", "count", "discountPrice", "couponPrice", "pointPrice", "deliveryPrice", "payPrice")
|
.containsExactly(200, 10, 0, 0, 0, 2500, 4500);
|
// 断言：SKU3 未选中，不计运费
|
assertThat(resultBO.getItems().get(2))
|
.extracting("price", "count", "discountPrice", "couponPrice", "pointPrice", "deliveryPrice", "payPrice")
|
.containsExactly(300, 1, 0, 0, 0, 0, 300);
|
}
|
|
@Test
|
@DisplayName("按件计算运费：包邮（订单总件数 >= 包邮件数 && 总金额 >= 包邮金额）")
|
public void testCalculate_expressTemplateFree() {
|
// SKU 1：100 * 2 = 200
|
// SKU 2：200 * 10 = 2000
|
// 总件数 12 >= 包邮件数 10 && 总金额 2200 >= 包邮金额 1000，包邮
|
templateRespBO.setFree(randomPojo(DeliveryExpressTemplateRespBO.Free.class,
|
item -> item.setFreeCount(10).setFreePrice(1000)));
|
mockAddress();
|
mockTemplate(templateRespBO);
|
|
// 调用
|
calculator.calculate(reqBO, resultBO);
|
|
// 断言
|
TradePriceCalculateRespBO.Price price = resultBO.getPrice();
|
assertThat(price)
|
.extracting("totalPrice", "discountPrice", "couponPrice", "pointPrice", "deliveryPrice", "payPrice")
|
.containsExactly(2200, 0, 0, 0, 0, 2200);
|
assertThat(resultBO.getItems()).hasSize(3);
|
assertThat(resultBO.getItems().get(0))
|
.extracting("price", "count", "discountPrice", "couponPrice", "pointPrice", "deliveryPrice", "payPrice")
|
.containsExactly(100, 2, 0, 0, 0, 0, 200);
|
assertThat(resultBO.getItems().get(1))
|
.extracting("price", "count", "discountPrice", "couponPrice", "pointPrice", "deliveryPrice", "payPrice")
|
.containsExactly(200, 10, 0, 0, 0, 0, 2000);
|
assertThat(resultBO.getItems().get(2))
|
.extracting("price", "count", "discountPrice", "couponPrice", "pointPrice", "deliveryPrice", "payPrice")
|
.containsExactly(300, 1, 0, 0, 0, 0, 300);
|
}
|
|
@Test
|
@DisplayName("按件计算运费：边界场景（总件数 = 包邮件数 → 包邮）")
|
public void testCalculate_expressTemplateFree_countBoundary() {
|
// 总件数 12 等于 包邮件数 12 && 总金额 2200 >= 包邮金额 1000，包邮
|
templateRespBO.setFree(randomPojo(DeliveryExpressTemplateRespBO.Free.class,
|
item -> item.setFreeCount(12).setFreePrice(1000)));
|
mockAddress();
|
mockTemplate(templateRespBO);
|
|
// 调用
|
calculator.calculate(reqBO, resultBO);
|
|
// 断言：包邮，运费 = 0
|
assertThat(resultBO.getPrice().getDeliveryPrice()).isEqualTo(0);
|
}
|
|
@Test
|
@DisplayName("按件计算运费：总金额未达到包邮金额 → 不包邮")
|
public void testCalculate_expressTemplateFree_priceNotMatch() {
|
// 总件数 12 > 包邮件数 10，但总金额 2200 < 包邮金额 5000，不包邮
|
templateRespBO.setFree(randomPojo(DeliveryExpressTemplateRespBO.Free.class,
|
item -> item.setFreeCount(10).setFreePrice(5000)));
|
mockAddress();
|
mockTemplate(templateRespBO);
|
|
// 调用
|
calculator.calculate(reqBO, resultBO);
|
|
// 断言：仍按运费模板计算 = 3000
|
assertThat(resultBO.getPrice().getDeliveryPrice()).isEqualTo(3000);
|
}
|
|
@Test
|
@DisplayName("按件计算运费：边界场景（总金额 = 包邮金额 → 包邮）")
|
public void testCalculate_expressTemplateFree_priceBoundary() {
|
// 总件数 12 >= 包邮件数 10 && 总金额 2200 等于 包邮金额 2200，包邮
|
templateRespBO.setFree(randomPojo(DeliveryExpressTemplateRespBO.Free.class,
|
item -> item.setFreeCount(10).setFreePrice(2200)));
|
mockAddress();
|
mockTemplate(templateRespBO);
|
|
// 调用
|
calculator.calculate(reqBO, resultBO);
|
|
// 断言：包邮，运费 = 0
|
assertThat(resultBO.getPrice().getDeliveryPrice()).isEqualTo(0);
|
}
|
|
@Test
|
@DisplayName("按重量计算运费")
|
public void testCalculate_expressTemplate_byWeight() {
|
// SKU1 weight 10 * count 2 = 20
|
// SKU2 weight 10 * count 10 = 100
|
// 总重量 120kg
|
// 运费：首件 1000 + 续件 ceil((120-10)/10)=11 倍 * 2000 = 23000
|
templateRespBO.setChargeMode(DeliveryExpressChargeModeEnum.WEIGHT.getType());
|
templateRespBO.setFree(randomPojo(DeliveryExpressTemplateRespBO.Free.class,
|
item -> item.setFreeCount(200).setFreePrice(100)));
|
mockAddress();
|
mockTemplate(templateRespBO);
|
|
// 调用
|
calculator.calculate(reqBO, resultBO);
|
|
// 断言
|
assertThat(resultBO.getPrice().getDeliveryPrice()).isEqualTo(23000);
|
}
|
|
@Test
|
@DisplayName("按体积计算运费")
|
public void testCalculate_expressTemplate_byVolume() {
|
// SKU1 volume 10 * count 2 = 20
|
// SKU2 volume 10 * count 10 = 100
|
// 总体积 120m³，与按重量场景同
|
templateRespBO.setChargeMode(DeliveryExpressChargeModeEnum.VOLUME.getType());
|
templateRespBO.setFree(randomPojo(DeliveryExpressTemplateRespBO.Free.class,
|
item -> item.setFreeCount(200).setFreePrice(100)));
|
mockAddress();
|
mockTemplate(templateRespBO);
|
|
// 调用
|
calculator.calculate(reqBO, resultBO);
|
|
// 断言
|
assertThat(resultBO.getPrice().getDeliveryPrice()).isEqualTo(23000);
|
}
|
|
private void mockAddress() {
|
MemberAddressRespDTO addressResp = randomPojo(MemberAddressRespDTO.class, item -> item.setAreaId(10));
|
when(addressApi.getAddress(eq(10L), eq(1L))).thenReturn(addressResp);
|
}
|
|
private void mockTemplate(DeliveryExpressTemplateRespBO template) {
|
when(deliveryExpressTemplateService.getExpressTemplateMapByIdsAndArea(eq(asSet(1L)), eq(10)))
|
.thenReturn(MapUtil.of(1L, template));
|
}
|
|
}
|
