Просмотр исходного кода

test(backend): RED contract test for supplier.afterSales.handle (S-cfc-240)

契约级单测(TDD-RED 阶段)为商品服务商售后/退款处理能力键 supplier.afterSales.handle
(SC-S-06,映射 docs/tdd/orchestration/sc-key-map.md)锚定契约行为:

- 锚定-1/2(绿证):AdminAfterSalesController /api/admin/shop/after-sales(list/detail/review/complete)
  与 AdminProductOrderController /api/admin/product/order(refund/approve|reject)宿主与端点齐备;
- RED-1(红):review(approve) 未校验订单退款状态(已 refunded/refundStatus=2 仍可放行)
  —— SC-S-06 边界「重复退款拦截」缺失;
- RED-2(红):complete 未校验订单退款已执行(status=refunded/refundStatus=2),退款未完成即标记
  completed —— 空转/假完成;
- RED-3(红):售后列表/处理无供应商行级隔离(list 无 @RequestAttribute("roles") 角色作用域、
  AfterSalesService 无按 supplierId/supplySystemId 过滤重载),跨商户可见/可处理;
- RED-4(红):list/detail/review/complete 均无角色守卫,非后台角色可越权处理售后。

风格同批:纯 JUnit5 + Mockito + 反射,无 Spring 上下文/无 DB/无外部服务。
RED 验证:mvn -Dtest=SupplierAfterSalesHandleContractTest test → Tests run: 6, Failures: 4(预期红)。
GREEN 阶段据此落地行为使绿。
E2E Test Bot 3 дней назад
Родитель
Сommit
094babfc94

+ 313 - 0
cfc-backend/src/test/java/com/etotem/cfc/unit/SupplierAfterSalesHandleContractTest.java

@@ -0,0 +1,313 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.etotem.cfc.common.Result;
+import com.etotem.cfc.entity.AfterSalesRequest;
+import com.etotem.cfc.entity.ProductOrder;
+import com.etotem.cfc.mapper.AfterSalesRequestMapper;
+import com.etotem.cfc.mapper.ProductOrderMapper;
+import com.etotem.cfc.service.AfterSalesService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestAttribute;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * 契约级单测(TDD-RED,S-cfc-240):能力键 {@code supplier.afterSales.handle}
+ * (商品服务商 · 售后/退款处理 SC-S-06)。
+ *
+ * <p><b>需求/设计溯源</b>:
+ * <ul>
+ *   <li>需求:{@code tests/user-scenarios/应用场景总览.md} <b>SC-S-06</b>(售后/退款处理:收售后 → 同意/拒 → 退款,
+ *       边界「重复退款拦截」);映射见 {@code docs/tdd/orchestration/sc-key-map.md}(S-cfc-240)。</li>
+ *   <li>设计:{@code docs/superpowers/api/API_REFERENCE.md} <b>§4.8</b> 商品/订单 + <b>§4.60.12</b>
+ *       <b>AdminAfterSalesController</b>{@code /api/admin/shop/after-sales}(list/detail/review/complete)+
+ *       <b>AdminProductOrderController</b>{@code /api/admin/product/order}(refund/approve|reject)。</li>
+ * </ul>
+ *
+ * <p><b>实现现状(src/main 逐类核实,2026-11-13 HEAD=3cdb534e7)</b>:契约宿主
+ * {@code AdminAfterSalesController}/{@code AdminProductOrderController}/{@code AfterSalesService} 均已合入主链
+ * (861f463d6 feat: add AfterSales module),端点骨架齐备;但 <b>契约行为未落地</b>:
+ * <ul>
+ *   <li><b>RED-1 重复退款拦截缺失</b>:{@code AfterSalesService.review(id, "approve", ...)} 未校验订单退款状态——
+ *       订单已 {@code refunded}/{@code refundStatus=2} 仍可再次审核通过(SC-S-06 边界「重复退款拦截」);</li>
+ *   <li><b>RED-2 空转/假完成缺失</b>:{@code AfterSalesService.complete(id)} 未校验订单退款已执行
+ *       ({@code status=refunded}/{@code refundStatus=2})即标记 {@code completed}——退款未执行也能"完成";</li>
+ *   <li><b>RED-3 行级隔离缺失</b>:AdminAfterSalesController.list 未按供应商作用域过滤(对比 AdminProductOrderController.list
+ *       的 B-5 行级隔离 {@code AdminRoles.isSupplierOnly → supplierUserId}),AfterSalesService 亦无按
+ *       {@code order.supplierId/supplySystemId} 过滤的重载——纯供应商可见/可处理全部商户售后;</li>
+ *   <li><b>RED-4 角色守卫缺失</b>:list/detail/review/complete 均未声明 {@code @RequestAttribute("roles")}
+ *       (JwtInterceptor 已注入 roles,B-142 双层防线约定 controller 层自身须角色守卫),非后台角色可越权处理售后。</li>
+ * </ul>
+ * 上述行为缺失处断言失败(红)=RED 完成;GREEN 阶段据此落地行为。
+ *
+ * <p><b>测试风格</b>:与同批 RED 契约测试({@code AfterSalesScS06ContractTest}/
+ * {@code AdminSupplierManageContractTest})一致——纯 JUnit5 + Mockito + 反射,无 Spring 上下文 / 无 DB / 无外部服务。
+ * 已落地骨架保留绿证锚定断言(锚定-1/2),契约缺失行为断言红。</p>
+ */
+class SupplierAfterSalesHandleContractTest {
+
+    /** 设计载体:管理端-商城售后(API_REFERENCE §4.8 / §4.60.12,SC-S-06) */
+    private static final String ADMIN_AFTER_SALES_CTRL =
+            "com.etotem.cfc.controller.admin.AdminAfterSalesController";
+
+    /** 设计载体:管理端-订单退款人工审批(API_REFERENCE §4.60.12,SC-S-06/SC-A-12) */
+    private static final String ADMIN_PRODUCT_ORDER_CTRL =
+            "com.etotem.cfc.controller.admin.AdminProductOrderController";
+
+    /** 设计载体:售后业务服务 */
+    private static final String AFTER_SALES_SERVICE = "com.etotem.cfc.service.AfterSalesService";
+
+    private AfterSalesService service;
+    private AfterSalesRequestMapper requestMapper;
+    private ProductOrderMapper orderMapper;
+
+    @BeforeEach
+    void setUp() throws Exception {
+        service = new AfterSalesService();
+        requestMapper = mock(AfterSalesRequestMapper.class);
+        orderMapper = mock(ProductOrderMapper.class);
+
+        inject(service, "afterSalesRequestMapper", requestMapper);
+        inject(service, "productOrderMapper", orderMapper);
+    }
+
+    // ==================== 绿证锚定(契约宿主骨架已合入主链) ====================
+
+    @Test
+    @DisplayName("锚定-1:AdminAfterSalesController 存在且暴露 /api/admin/shop/after-sales list/detail/review/complete")
+    void anchor_adminAfterSalesControllerExists() {
+        Class<?> ctrl = loadClass(ADMIN_AFTER_SALES_CTRL);
+        assertTrue(ctrl != null, "[supplier.afterSales.handle] 契约宿主 AdminAfterSalesController 未实现(实现未落地)。");
+
+        assertTrue(hasMapping(ctrl, "/api/admin/shop/after-sales"),
+                "类级 @RequestMapping 应为 /api/admin/shop/after-sales(API_REFERENCE §4.60.12)。");
+
+        assertTrue(hasPublicMethod(ctrl, "list") && hasPublicMethod(ctrl, "detail")
+                        && hasPublicMethod(ctrl, "review") && hasPublicMethod(ctrl, "complete"),
+                "合同端点 list/detail/review/complete 必须齐全(SC-S-06 售后处理载体)。");
+    }
+
+    @Test
+    @DisplayName("锚定-2:AdminProductOrderController 存在且暴露 refund/approve + refund/reject")
+    void anchor_adminProductOrderControllerExists() {
+        Class<?> ctrl = loadClass(ADMIN_PRODUCT_ORDER_CTRL);
+        assertTrue(ctrl != null, "[supplier.afterSales.handle] 契约宿主 AdminProductOrderController 未实现(实现未落地)。");
+
+        assertTrue(hasPublicMethod(ctrl, "approveRefund") && hasPublicMethod(ctrl, "rejectRefund"),
+                "退款人工审批端点 approveRefund/rejectRefund 必须存在(API_REFERENCE §4.60.12)。");
+        assertTrue(methodHasPostMapping(ctrl, "approveRefund", "/refund/approve")
+                        && methodHasPostMapping(ctrl, "rejectRefund", "/refund/reject"),
+                "approveRefund→POST /refund/approve、rejectRefund→POST /refund/reject 路径契约。");
+    }
+
+    // ==================== RED-1:重复退款拦截——审核通过须校验订单退款状态(SC-S-06 边界) ====================
+
+    @Test
+    @DisplayName("RED-1 重复退款拦截:订单已退款(refunded/refundStatus=2)后 review(approve) 须拒绝")
+    void review_onAlreadyRefundedOrder_mustReject() {
+        // 售后申请处于待审核;但其关联订单已完成退款(SC-S-06 边界「重复退款拦截」)
+        AfterSalesRequest req = request(500L, "pending", 1L);
+        when(requestMapper.selectById(500L)).thenReturn(req);
+
+        ProductOrder order = order(100L, "PO_REFUNDED");
+        order.setStatus("refunded");
+        order.setRefundStatus(2);
+        when(orderMapper.selectById(100L)).thenReturn(order);
+
+        Result<String> r = service.review(500L, "approve", null, 9L);
+
+        assertEquals(500, r.getCode(),
+                "RED[supplier.afterSales.handle] 契约事实:review(approve) 未校验订单退款状态,"
+                        + "订单已 refunded/refundStatus=2 仍放行 code=" + r.getCode()
+                        + "/msg=" + r.getMessage()
+                        + " —— SC-S-06 边界「重复退款拦截」缺失,GREEN 须在 review 通过前校验 order.refundStatus!=2。");
+        assertEquals("pending", req.getStatus(), "拒绝时申请状态不应被修改");
+    }
+
+    // ==================== RED-2:空转/假完成拦截——complete 须校验订单退款已执行(SC-S-06 边界) ====================
+
+    @Test
+    @DisplayName("RED-2 空转/假完成拦截:订单退款未执行(refunding/refundStatus=1)时 complete 须拒绝")
+    void complete_withoutOrderRefundExecuted_mustReject() {
+        // 售后申请已批准,但关联订单退款尚未执行(order 仍 refunding、refundStatus=1)
+        AfterSalesRequest req = request(500L, "approved", 1L);
+        when(requestMapper.selectById(500L)).thenReturn(req);
+
+        ProductOrder order = order(100L, "PO_PENDING_REFUND");
+        order.setStatus("refunding");
+        order.setRefundStatus(1);
+        when(orderMapper.selectById(100L)).thenReturn(order);
+
+        Result<String> r = service.complete(500L);
+
+        assertEquals(500, r.getCode(),
+                "RED[supplier.afterSales.handle] 契约事实:complete 未校验订单退款已执行"
+                        + "(order.status=refunded / refundStatus=2),退款未完成即标记 completed,code=" + r.getCode()
+                        + "/msg=" + r.getMessage()
+                        + " —— 空转/假完成,SC-S-06 边界「重复退款拦截」缺失,GREEN 须在 complete 前校验订单退款已执行。");
+        assertEquals("approved", req.getStatus(), "拒绝时申请状态不应被修改");
+    }
+
+    // ==================== RED-3:供应商行级隔离(跨商户可见性) ====================
+
+    @Test
+    @DisplayName("RED-3 行级隔离:售后列表/处理须按供应商作用域过滤(对比 AdminProductOrderController B-5)")
+    void supplierRowLevelIsolation_missing() {
+        Object ctrl = contractHost(ADMIN_AFTER_SALES_CTRL);
+        // 契约:list 须声明 @RequestAttribute("roles") 并按 AdminRoles.isSupplierOnly → supplierUserId 过滤(对照 AdminProductOrderController.list)
+        boolean listCarriesRoles = methodHasRequestAttribute(ctrl, "list", "roles");
+
+        Object svc = contractHost(AFTER_SALES_SERVICE);
+        // 契约:服务层须提供按供应商作用域的售后列表(status + 供应商身份)
+        boolean supplierScopedList = hasPublicMethodWithParams(svc, "adminList", String.class, Long.class)
+                || hasPublicMethodWithParams(svc, "adminList", Long.class, String.class)
+                || hasPublicMethodWithParams(svc, "adminListBySupplier", Long.class, String.class)
+                || hasPublicMethodWithParams(svc, "adminListBySupplier", String.class, Long.class);
+
+        assertTrue(listCarriesRoles || supplierScopedList,
+                "RED[supplier.afterSales.handle] 供应商售后处理无行级隔离:"
+                        + "AdminAfterSalesController.list 未声明 @RequestAttribute(\"roles\") 角色作用域,"
+                        + "AfterSalesService 亦无按供应商维度(order.supplierId/supplySystemId)过滤的列表重载——"
+                        + "纯供应商 role=list 将返回/可处理全部商户售后(跨商户隔离缺失)。"
+                        + "GREEN 阶段须参照 AdminProductOrderController.list 的 B-5 行级隔离落地。");
+    }
+
+    // ==================== RED-4:角色守卫(越权防护,B-142 双层防线) ====================
+
+    @Test
+    @DisplayName("RED-4 角色守卫:售后处理端点须声明 @RequestAttribute(\"roles\"),非后台角色不得越权处理")
+    void roleGuard_missing_onHandleEndpoints() {
+        Object ctrl = contractHost(ADMIN_AFTER_SALES_CTRL);
+        boolean anyRoleGuard = methodHasRequestAttribute(ctrl, "list", "roles")
+                || methodHasRequestAttribute(ctrl, "detail", "roles")
+                || methodHasRequestAttribute(ctrl, "review", "roles")
+                || methodHasRequestAttribute(ctrl, "complete", "roles");
+
+        assertTrue(anyRoleGuard,
+                "RED[supplier.afterSales.handle] 售后处理端点无角色守卫:"
+                        + "AdminAfterSalesController 的 list/detail/review/complete 均未声明 @RequestAttribute(\"roles\")"
+                        + "(JwtInterceptor 已注入 roles 属性,B-142 约定 controller 层自身须守卫,且 /api/admin/** 仅保证登录不保证角色)"
+                        + "—— 非后台角色(如 parent/teacher)可越权查看/审核/完成售后。GREEN 阶段须补角色守卫(supplier/admin 等域内角色)。");
+    }
+
+    // ==================== 测试数据辅助(同 AfterSalesScS06ContractTest 风格) ====================
+
+    private AfterSalesRequest request(Long id, String status, Long userId) {
+        AfterSalesRequest r = new AfterSalesRequest();
+        r.setId(id);
+        r.setOrderId(100L);
+        r.setOrderNo("PO_AS");
+        r.setUserId(userId);
+        r.setStatus(status);
+        r.setRefundAmount(9900);
+        return r;
+    }
+
+    private ProductOrder order(Long id, String orderNo) {
+        ProductOrder o = new ProductOrder();
+        o.setId(id);
+        o.setOrderNo(orderNo);
+        o.setBuyerId(1L);
+        o.setMoneyAmount(9900);
+        return o;
+    }
+
+    // ==================== 反射辅助(锚定契约宿主,避免编译期依赖未落地类) ====================
+
+    private Class<?> loadClass(String name) {
+        try {
+            return Class.forName(name, false, Thread.currentThread().getContextClassLoader());
+        } catch (ClassNotFoundException e) {
+            return null;
+        }
+    }
+
+    private void inject(Object target, String field, Object value) throws Exception {
+        Field f = target.getClass().getDeclaredField(field);
+        f.setAccessible(true);
+        f.set(target, value);
+    }
+
+    /** 实例化契约宿主;宿主缺失即断言失败(红)。 */
+    private Object contractHost(String fqcn) {
+        try {
+            Class<?> clazz = Class.forName(fqcn);
+            return clazz.getDeclaredConstructor().newInstance();
+        } catch (ClassNotFoundException e) {
+            org.junit.jupiter.api.Assertions.fail(
+                    "RED[supplier.afterSales.handle] 契约宿主 " + simpleName(fqcn) + " 未实现(实现未落地):" + e.getMessage());
+            throw new IllegalStateException("unreachable");
+        } catch (Exception e) {
+            org.junit.jupiter.api.Assertions.fail("契约宿主 " + fqcn + " 实例化失败:" + e.getMessage());
+            throw new IllegalStateException("unreachable");
+        }
+    }
+
+    private boolean hasMapping(Class<?> clazz, String expectedPath) {
+        RequestMapping rm = clazz.getAnnotation(RequestMapping.class);
+        return rm != null && rm.value().length > 0 && expectedPath.equals(rm.value()[0]);
+    }
+
+    private boolean hasPublicMethod(Class<?> clazz, String name) {
+        for (Method m : clazz.getMethods()) {
+            if (m.getName().equals(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean hasPublicMethodWithParams(Object host, String name, Class<?>... paramTypes) {
+        for (Method m : host.getClass().getMethods()) {
+            if (m.getName().equals(name) && java.util.Arrays.equals(m.getParameterTypes(), paramTypes)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean methodHasPostMapping(Class<?> clazz, String methodName, String path) {
+        for (Method m : clazz.getMethods()) {
+            if (!m.getName().equals(methodName)) {
+                continue;
+            }
+            PostMapping pm = m.getAnnotation(PostMapping.class);
+            if (pm != null && pm.value().length > 0 && path.equals(pm.value()[0])) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean methodHasRequestAttribute(Object host, String methodName, String attrValue) {
+        for (Method m : host.getClass().getMethods()) {
+            if (!m.getName().equals(methodName)) {
+                continue;
+            }
+            for (Parameter p : m.getParameters()) {
+                RequestAttribute ra = p.getAnnotation(RequestAttribute.class);
+                if (ra != null && attrValue.equals(ra.value())) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private String simpleName(String fqcn) {
+        int idx = fqcn.lastIndexOf('.');
+        return idx >= 0 ? fqcn.substring(idx + 1) : fqcn;
+    }
+}