gxwebsoft/mp-java
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(shop): 实现商品销量累加和跨租户查询功能

Browse Source 
- 添加商品销量累加功能，确保支付成功后更新销量- 实现跨租户查询用户和订单商品的功能
- 修复支付回调中的错误代码
-优化日志记录和异常处理
This commit is contained in:
赵忠林
2025-08-23 03:43:21 +08:00
parent 2a8d87a4d1
commit cccc13df79
25 changed files with 1453 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
src/test/java/com/gxwebsoft/common/system/service/UserIgnoreTenantTest.java Normal file
View File

@@ -0,0 +1,100 @@
package com.gxwebsoft.common.system.service;
import com.gxwebsoft.common.system.entity.User;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import javax.annotation.Resource;
/**
* 用户忽略租户隔离功能测试
*
* @author WebSoft
* @since 2025-08-23
*/
@Slf4j
@SpringBootTest
@ActiveProfiles("dev")
public class UserIgnoreTenantTest {
@Resource
private UserService userService;
/**
* 测试忽略租户隔离查询用户
*/
@Test
public void testGetByIdIgnoreTenant() {
// 测试用户ID（请根据实际数据库中的用户ID进行调整）
Integer testUserId = 1;
log.info("=== 开始测试忽略租户隔离查询用户功能 ===");
// 1. 使用普通方法查询用户（受租户隔离影响）
User userNormal = userService.getById(testUserId);
log.info("普通查询结果 - 用户ID: {}, 用户信息: {}", testUserId,
userNormal != null ? userNormal.getUsername() : "null");
// 2. 使用忽略租户隔离方法查询用户
User userIgnoreTenant = userService.getByIdIgnoreTenant(testUserId);
log.info("忽略租户隔离查询结果 - 用户ID: {}, 用户信息: {}", testUserId,
userIgnoreTenant != null ? userIgnoreTenant.getUsername() : "null");
// 3. 验证结果
if (userIgnoreTenant != null) {
log.info("✅ 忽略租户隔离查询成功！");
log.info("用户详情 - ID: {}, 用户名: {}, 昵称: {}, 租户ID: {}",
userIgnoreTenant.getUserId(),
userIgnoreTenant.getUsername(),
userIgnoreTenant.getNickname(),
userIgnoreTenant.getTenantId());
} else {
log.error("❌ 忽略租户隔离查询失败！");
}
log.info("=== 忽略租户隔离查询用户功能测试完成 ===");
}
/**
* 测试参数验证
*/
@Test
public void testGetByIdIgnoreTenantValidation() {
log.info("=== 开始测试参数验证 ===");
// 测试null用户ID
User result1 = userService.getByIdIgnoreTenant(null);
log.info("null用户ID测试结果: {}", result1 == null ? "成功(返回null)" : "失败");
// 测试不存在的用户ID
User result2 = userService.getByIdIgnoreTenant(999999);
log.info("不存在用户ID测试结果: {}", result2 == null ? "成功(返回null)" : "失败");
log.info("=== 参数验证测试完成 ===");
}
/**
* 测试跨租户查询
*/
@Test
public void testCrossTenantQuery() {
log.info("=== 开始测试跨租户查询 ===");
// 查询不同租户的用户（请根据实际数据调整）
Integer[] testUserIds = {1, 2, 3, 4, 5};
for (Integer userId : testUserIds) {
User user = userService.getByIdIgnoreTenant(userId);
if (user != null) {
log.info("用户ID: {}, 用户名: {}, 租户ID: {}",
user.getUserId(), user.getUsername(), user.getTenantId());
} else {
log.info("用户ID: {} - 不存在", userId);
}
}
log.info("=== 跨租户查询测试完成 ===");
}
}

145
src/test/java/com/gxwebsoft/shop/service/ShopGoodsSalesTest.java Normal file
View File

@@ -0,0 +1,145 @@
package com.gxwebsoft.shop.service;
import com.gxwebsoft.shop.entity.ShopGoods;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import javax.annotation.Resource;
/**
* 商品销量累加功能测试
*
* @author WebSoft
* @since 2025-08-23
*/
@Slf4j
@SpringBootTest
@ActiveProfiles("dev")
public class ShopGoodsSalesTest {
@Resource
private ShopGoodsService shopGoodsService;
/**
* 测试累加商品销量功能
*/
@Test
public void testAddSaleCount() {
// 测试商品ID（请根据实际数据库中的商品ID进行调整）
Integer testGoodsId = 1;
Integer addCount = 5;
log.info("=== 开始测试商品销量累加功能 ===");
// 1. 查询商品当前销量
ShopGoods goodsBefore = shopGoodsService.getById(testGoodsId);
if (goodsBefore == null) {
log.error("测试失败：商品不存在 - 商品ID: {}", testGoodsId);
return;
}
Integer salesBefore = goodsBefore.getSales() != null ? goodsBefore.getSales() : 0;
log.info("累加前商品销量 - 商品ID: {}, 商品名称: {}, 当前销量: {}",
testGoodsId, goodsBefore.getName(), salesBefore);
// 2. 执行销量累加
boolean result = shopGoodsService.addSaleCount(testGoodsId, addCount);
log.info("销量累加操作结果: {}", result ? "成功" : "失败");
// 3. 查询累加后的销量
ShopGoods goodsAfter = shopGoodsService.getById(testGoodsId);
Integer salesAfter = goodsAfter.getSales() != null ? goodsAfter.getSales() : 0;
log.info("累加后商品销量 - 商品ID: {}, 商品名称: {}, 累加后销量: {}",
testGoodsId, goodsAfter.getName(), salesAfter);
// 4. 验证结果
Integer expectedSales = salesBefore + addCount;
if (salesAfter.equals(expectedSales)) {
log.info("✅ 测试成功！销量正确累加 - 预期: {}, 实际: {}", expectedSales, salesAfter);
} else {
log.error("❌ 测试失败！销量累加不正确 - 预期: {}, 实际: {}", expectedSales, salesAfter);
}
log.info("=== 商品销量累加功能测试完成 ===");
}
/**
* 测试参数验证
*/
@Test
public void testAddSaleCountValidation() {
log.info("=== 开始测试参数验证 ===");
// 测试null商品ID
boolean result1 = shopGoodsService.addSaleCount(null, 5);
log.info("null商品ID测试结果: {}", result1 ? "失败(应该返回false)" : "成功");
// 测试null销量
boolean result2 = shopGoodsService.addSaleCount(1, null);
log.info("null销量测试结果: {}", result2 ? "失败(应该返回false)" : "成功");
// 测试负数销量
boolean result3 = shopGoodsService.addSaleCount(1, -1);
log.info("负数销量测试结果: {}", result3 ? "失败(应该返回false)" : "成功");
// 测试零销量
boolean result4 = shopGoodsService.addSaleCount(1, 0);
log.info("零销量测试结果: {}", result4 ? "失败(应该返回false)" : "成功");
// 测试不存在的商品ID
boolean result5 = shopGoodsService.addSaleCount(999999, 5);
log.info("不存在商品ID测试结果: {}", result5 ? "失败(应该返回false)" : "成功");
log.info("=== 参数验证测试完成 ===");
}
/**
* 测试大批量累加
*/
@Test
public void testBatchAddSaleCount() {
Integer testGoodsId = 1;
log.info("=== 开始测试批量累加 ===");
// 查询初始销量
ShopGoods goodsBefore = shopGoodsService.getById(testGoodsId);
if (goodsBefore == null) {
log.error("测试失败：商品不存在 - 商品ID: {}", testGoodsId);
return;
}
Integer salesBefore = goodsBefore.getSales() != null ? goodsBefore.getSales() : 0;
log.info("批量累加前销量: {}", salesBefore);
// 模拟多次购买
int totalAdded = 0;
for (int i = 1; i <= 10; i++) {
boolean result = shopGoodsService.addSaleCount(testGoodsId, i);
if (result) {
totalAdded += i;
log.info("第{}次累加成功，累加数量: {}", i, i);
} else {
log.error("第{}次累加失败", i);
}
}
// 验证最终结果
ShopGoods goodsAfter = shopGoodsService.getById(testGoodsId);
Integer salesAfter = goodsAfter.getSales() != null ? goodsAfter.getSales() : 0;
Integer expectedSales = salesBefore + totalAdded;
log.info("批量累加结果 - 累加前: {}, 总累加量: {}, 累加后: {}, 预期: {}",
salesBefore, totalAdded, salesAfter, expectedSales);
if (salesAfter.equals(expectedSales)) {
log.info("✅ 批量累加测试成功！");
} else {
log.error("❌ 批量累加测试失败！");
}
log.info("=== 批量累加测试完成 ===");
}
}

136
src/test/java/com/gxwebsoft/shop/service/ShopOrderGoodsIgnoreTenantTest.java Normal file
View File

@@ -0,0 +1,136 @@
package com.gxwebsoft.shop.service;
import com.gxwebsoft.shop.entity.ShopOrderGoods;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import javax.annotation.Resource;
import java.util.List;
/**
* 订单商品忽略租户隔离功能测试
*
* @author WebSoft
* @since 2025-08-23
*/
@Slf4j
@SpringBootTest
@ActiveProfiles("dev")
public class ShopOrderGoodsIgnoreTenantTest {
@Resource
private ShopOrderGoodsService shopOrderGoodsService;
/**
* 测试忽略租户隔离查询订单商品
*/
@Test
public void testGetListByOrderIdIgnoreTenant() {
// 测试订单ID（请根据实际数据库中的订单ID进行调整）
Integer testOrderId = 1;
log.info("=== 开始测试忽略租户隔离查询订单商品功能 ===");
// 1. 使用普通方法查询订单商品（受租户隔离影响）
List<ShopOrderGoods> orderGoodsNormal = shopOrderGoodsService.getListByOrderId(testOrderId);
log.info("普通查询结果 - 订单ID: {}, 商品数量: {}", testOrderId,
orderGoodsNormal != null ? orderGoodsNormal.size() : 0);
// 2. 使用忽略租户隔离方法查询订单商品
List<ShopOrderGoods> orderGoodsIgnoreTenant = shopOrderGoodsService.getListByOrderIdIgnoreTenant(testOrderId);
log.info("忽略租户隔离查询结果 - 订单ID: {}, 商品数量: {}", testOrderId,
orderGoodsIgnoreTenant != null ? orderGoodsIgnoreTenant.size() : 0);
// 3. 验证结果
if (orderGoodsIgnoreTenant != null && !orderGoodsIgnoreTenant.isEmpty()) {
log.info("✅ 忽略租户隔离查询成功！");
for (ShopOrderGoods orderGoods : orderGoodsIgnoreTenant) {
log.info("订单商品详情 - ID: {}, 商品ID: {}, 商品名称: {}, 数量: {}, 租户ID: {}",
orderGoods.getId(),
orderGoods.getGoodsId(),
orderGoods.getGoodsName(),
orderGoods.getTotalNum(),
orderGoods.getTenantId());
}
} else {
log.warn("⚠️ 忽略租户隔离查询结果为空，可能订单不存在或没有商品");
}
log.info("=== 忽略租户隔离查询订单商品功能测试完成 ===");
}
/**
* 测试参数验证
*/
@Test
public void testGetListByOrderIdIgnoreTenantValidation() {
log.info("=== 开始测试参数验证 ===");
// 测试null订单ID
List<ShopOrderGoods> result1 = shopOrderGoodsService.getListByOrderIdIgnoreTenant(null);
log.info("null订单ID测试结果: {}", result1.isEmpty() ? "成功(返回空列表)" : "失败");
// 测试不存在的订单ID
List<ShopOrderGoods> result2 = shopOrderGoodsService.getListByOrderIdIgnoreTenant(999999);
log.info("不存在订单ID测试结果: {}", result2.isEmpty() ? "成功(返回空列表)" : "失败");
log.info("=== 参数验证测试完成 ===");
}
/**
* 测试跨租户查询
*/
@Test
public void testCrossTenantQuery() {
log.info("=== 开始测试跨租户查询 ===");
// 查询不同租户的订单商品（请根据实际数据调整）
Integer[] testOrderIds = {1, 2, 3, 4, 5};
for (Integer orderId : testOrderIds) {
List<ShopOrderGoods> orderGoodsList = shopOrderGoodsService.getListByOrderIdIgnoreTenant(orderId);
if (orderGoodsList != null && !orderGoodsList.isEmpty()) {
log.info("订单ID: {}, 商品数量: {}", orderId, orderGoodsList.size());
for (ShopOrderGoods orderGoods : orderGoodsList) {
log.info(" - 商品: {} (ID: {}), 数量: {}, 租户: {}",
orderGoods.getGoodsName(),
orderGoods.getGoodsId(),
orderGoods.getTotalNum(),
orderGoods.getTenantId());
}
} else {
log.info("订单ID: {} - 无商品或不存在", orderId);
}
}
log.info("=== 跨租户查询测试完成 ===");
}
/**
* 测试批量查询性能
*/
@Test
public void testBatchQuery() {
log.info("=== 开始测试批量查询性能 ===");
Integer[] testOrderIds = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
long startTime = System.currentTimeMillis();
int totalGoods = 0;
for (Integer orderId : testOrderIds) {
List<ShopOrderGoods> orderGoodsList = shopOrderGoodsService.getListByOrderIdIgnoreTenant(orderId);
totalGoods += orderGoodsList.size();
}
long endTime = System.currentTimeMillis();
long duration = endTime - startTime;
log.info("批量查询结果 - 查询订单数: {}, 总商品数: {}, 耗时: {}ms",
testOrderIds.length, totalGoods, duration);
log.info("=== 批量查询性能测试完成 ===");
}
}