Selaa lähdekoodia

S-cfc-168: 合入 membership.plan.purchase 契约 RED 测试(预期红 7/7)

task/S-cfc-168: 4d999a0fe MembershipPlanPurchaseContractTest(SC-P-58 购买会员/套餐,契约新增能力
membership.plan.purchase 实现未落地,RED 阶段:契约入口缺失 / createOrder 无幂等守卫 / 回调开通失败
订单停留 paid 半态)。
E2E Test Bot 5 päivää sitten
vanhempi
sitoutus
95a74b69a8

+ 326 - 0
cfc-backend/src/test/java/com/etotem/cfc/unit/MembershipPlanPurchaseContractTest.java

@@ -0,0 +1,326 @@
+package com.etotem.cfc.unit;
+
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.etotem.cfc.controller.MembershipController;
+import com.etotem.cfc.dto.PaymentOrderDTO;
+import com.etotem.cfc.entity.FamilyMembership;
+import com.etotem.cfc.entity.MembershipLevel;
+import com.etotem.cfc.entity.PaymentOrder;
+import com.etotem.cfc.mapper.FamilyMembershipMapper;
+import com.etotem.cfc.mapper.FamilyMapper;
+import com.etotem.cfc.mapper.MembershipLevelMapper;
+import com.etotem.cfc.mapper.PaymentOrderMapper;
+import com.etotem.cfc.mapper.UserMapper;
+import com.etotem.cfc.service.CfCommissionService;
+import com.etotem.cfc.service.CouponService;
+import com.etotem.cfc.service.MembershipService;
+import com.etotem.cfc.service.VirtualGoodsConfigService;
+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 java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.Date;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * 契约级单测:会员档位购买(能力键 {@code membership.plan.purchase},SC-P-58)。
+ *
+ * <p><b>需求/溯源(tests/user-scenarios/应用场景总览.md SC-P-58 · 购买会员/套餐,业务域 F 商城与会员)</b></p>
+ * <blockquote>
+ *   目标:解锁高级能力。流程:选档位 → 支付 → 权益生效。
+ *   边界:<b>支付失败回滚</b>;<b>重复购买幂等</b>。模块:{@code MemberController}(现有载体
+ *   {@code MembershipController} / {@code MembershipService})。
+ * </blockquote>
+ *
+ * <p><b>设计锚点(docs/superpowers/api/API_REFERENCE.md)</b></p>
+ * <ul>
+ *   <li>§4.50 会员权益对比表 {@code POST /api/membership/compare}:购买页/会员中心的档位卡片与权益
+ *       对比已后端化(已合入 origin/cfclub);同节注明 {@code /api/membership/plans}
+ *       为<b>购买档位列表</b>(过滤 LIFETIME/PROVIDER,附 maxChildren/maxTasksPerDay)。</li>
+ *   <li>§4.43 商品赠送会员 {@code POST /api/membership/gift-membership-progress}:家庭维度赠会员链路
+ *       (已合入 origin/cfclub)。</li>
+ *   <li>购买支付现状载体:{@code MembershipController#createOrder}({@code POST /api/membership/orders})
+ *       → {@code MembershipService#createOrder} / {@code #createOrderWithPayType} /
+ *       {@code #processPaymentCallback}(已存在)。</li>
+ * </ul>
+ *
+ * <p><b>契约缺口(本期实现未落地,全部断言预期红)</b></p>
+ * <ul>
+ *   <li><b>契约入口缺失</b>:无一段式档位购买入口({@code MembershipService#purchasePlan(...)} 契约方法、
+ *       {@code POST /api/membership/plan/purchase} 控制器端点均不存在);无支付失败回滚入口
+ *       ({@code markMembershipOrderFailed(orderNo)} 不存在)。</li>
+ *   <li><b>重复购买幂等缺失</b>:{@code createOrder} 不检查家庭<i>已有有效会员</i>与<i>已有待支付同类订单</i>,
+ *       重复购买每次都盲目生成新订单(SC-P-58 边界「重复购买幂等」未实现)。</li>
+ *   <li><b>支付失败回滚缺失</b>:{@code processPaymentCallback} 先置订单 {@code paid} 再开通会员,
+ *       开通失败(如家庭无关联用户)时订单已停留 {@code paid}、会员记录缺失——半态不回滚
+ *       (SC-P-58 边界「支付失败回滚」未实现)。</li>
+ * </ul>
+ *
+ * <p><b>契约方法签名(GREEN 阶段实现方按此落地,落地后本测试自动转绿)</b></p>
+ * <ul>
+ *   <li>{@code Map<String,Object> purchasePlan(Long userId, Long familyId, String levelCode,
+ *       String period, Long couponId)} —— 一段式档位购买:按当前支付模式返回待支付订单 + 支付参数;
+ *       无家庭时<i>最先</i>抛「请先创建或加入家庭后再购买会员」(fail-fast,权限流)。</li>
+ *   <li>{@code boolean markMembershipOrderFailed(String orderNo)} —— 支付失败回滚入口:
+ *       将订单置失败态(不置 paid / 不生会员记录),重复调用幂等。</li>
+ *   <li>{@code createOrder} 追加幂等守卫:家庭已有有效付费会员(paid 未过期)→ 拒绝重复购买;
+ *       已有同类待支付订单 → 复用既有订单不新插入。</li>
+ *   <li>{@code processPaymentCallback} 开通失败时回滚订单状态(不得停留 paid)。</li>
+ * </ul>
+ *
+ * <p><b>测试范围</b>:纯 Mockito + 反射,无 Spring 上下文 / 无 DB / 无真实微信;宿主契约方法用
+ * 反射锚定(避免直接调用不存在方法导致编译失败),运行时缺失即断言失败(红),与
+ * TeamStarMultiplierContractTest / TeamProfitHookContractTest / FamilyJoinValidationRulesContractTest
+ * 同批风格一致。</p>
+ *
+ * <p><b>权限流</b>:购买需登录({@code JwtInterceptor} 拦截 {@code /api/**})+ 家庭上下文;
+ * 本类以「无家庭 → 拒绝购买」覆盖权限维度(familyId=null fail-fast 契约)。</p>
+ */
+class MembershipPlanPurchaseContractTest {
+
+    private static final String KEY = "[membership.plan.purchase]";
+
+    /** 契约入口购买方法与无家庭拒绝时最先抛出的业务提示(与 createOrder 既有文案同源) */
+    private static final String MSG_NO_FAMILY = "请先创建或加入家庭后再购买会员";
+
+    private MembershipService service;
+    private MembershipLevelMapper levelMapper;
+    private PaymentOrderMapper paymentOrderMapper;
+    private FamilyMembershipMapper membershipMapper;
+    private FamilyMapper familyMapper;
+    private UserMapper userMapper;
+    private CouponService couponService;
+    private CfCommissionService cfCommissionService;
+    private VirtualGoodsConfigService virtualGoodsConfigService;
+
+    @BeforeEach
+    void setUp() throws Exception {
+        service = new MembershipService();
+        levelMapper = mock(MembershipLevelMapper.class);
+        paymentOrderMapper = mock(PaymentOrderMapper.class);
+        membershipMapper = mock(FamilyMembershipMapper.class);
+        familyMapper = mock(FamilyMapper.class);
+        userMapper = mock(UserMapper.class);
+        couponService = mock(CouponService.class);
+        cfCommissionService = mock(CfCommissionService.class);
+        virtualGoodsConfigService = mock(VirtualGoodsConfigService.class);
+
+        inject(service, "levelMapper", levelMapper);
+        inject(service, "paymentOrderMapper", paymentOrderMapper);
+        inject(service, "membershipMapper", membershipMapper);
+        inject(service, "familyMapper", familyMapper);
+        inject(service, "userMapper", userMapper);
+        inject(service, "couponService", couponService);
+        inject(service, "cfCommissionService", cfCommissionService);
+        inject(service, "virtualGoodsConfigService", virtualGoodsConfigService);
+    }
+
+    private static void inject(Object target, String field, Object value) throws Exception {
+        Field f = target.getClass().getDeclaredField(field);
+        f.setAccessible(true);
+        f.set(target, value);
+    }
+
+    // ==================== 正常流(契约入口:选档位 → 支付) ====================
+
+    @Test
+    @DisplayName("正常流-1:MembershipService 应落地 purchasePlan 一段式档位购买契约方法")
+    void purchasePlan_contractMethod_landed() {
+        assertTrue(hasMethod(MembershipService.class, "purchasePlan", 5),
+                KEY + " MembershipService 未落地 purchasePlan(userId, familyId, levelCode, period, couponId)"
+                        + " 契约方法(SC-P-58 选档位→支付一段式购买入口,当前实现未落地)。");
+    }
+
+    @Test
+    @DisplayName("正常流-2:MembershipController 应暴露 POST /api/membership/plan/purchase 端点")
+    void planPurchase_endpoint_exposed() {
+        boolean found = false;
+        for (Method m : MembershipController.class.getDeclaredMethods()) {
+            PostMapping pm = m.getAnnotation(PostMapping.class);
+            if (pm == null) {
+                continue;
+            }
+            for (String v : pm.value()) {
+                if ("/plan/purchase".equals(v)) {
+                    found = true;
+                    break;
+                }
+            }
+        }
+        assertTrue(found,
+                KEY + " MembershipController 未暴露 POST /api/membership/plan/purchase 端点"
+                        + "(SC-P-58 购买页档位购买契约入口,当前实现未落地)。");
+    }
+
+    // ==================== 边界流(SC-P-58:重复购买幂等) ====================
+
+    @Test
+    @DisplayName("边界流-1:家庭已有有效付费会员时重复购买应幂等拦截,不得生成新订单")
+    void repeatPurchase_activeMembership_blocked_noNewOrder() {
+        // 契约(重复购买幂等):同一家庭对同一档位已存在有效付费会员(paid 未过期)时,
+        // 重复购买不得盲目再生成待支付订单——应拒绝并提示(续费走 SC-P-60 流程)。
+        when(membershipMapper.selectOne(any(Wrapper.class))).thenReturn(activeMembership("FAMILY"));
+        when(levelMapper.selectOne(any(Wrapper.class))).thenReturn(familyLevel());
+        when(virtualGoodsConfigService.getEnabled("MEMBERSHIP", "FAMILY")).thenReturn(null);
+
+        try {
+            service.createOrder(1L, 5L, "FAMILY", "wechat", "yearly", null);
+            fail(KEY + " 重复购买未被幂等拦截:家庭已有有效 FAMILY 会员时仍生成新订单(SC-P-58 边界:重复购买幂等)。");
+        } catch (RuntimeException ex) {
+            assertTrue(ex.getMessage().contains("有效会员"),
+                    KEY + " 重复购买拒绝文案应说明「已有有效会员」:实际 " + ex.getMessage());
+        }
+        verify(paymentOrderMapper, never()).insert(any(PaymentOrder.class));
+    }
+
+    @Test
+    @DisplayName("边界流-2:已有同类待支付订单时重复购买应复用既有订单,不重复插入")
+    void repeatPurchase_pendingOrderSamePlan_reuseNoDuplicate() {
+        // 契约(重复购买幂等):家庭已有「同等级、待支付」的购买订单时,再次购买应复用既有订单,
+        // 幂等返回已存在待支付单,禁止为同一意图重复落单。
+        when(levelMapper.selectOne(any(Wrapper.class))).thenReturn(familyLevel());
+        when(virtualGoodsConfigService.getEnabled("MEMBERSHIP", "FAMILY")).thenReturn(null);
+
+        service.createOrder(1L, 5L, "FAMILY", "wechat", "yearly", null);
+
+        verify(paymentOrderMapper, never()).insert(any(PaymentOrder.class));
+    }
+
+    // ==================== 边界流(SC-P-58:支付失败回滚) ====================
+
+    @Test
+    @DisplayName("边界流-3:MembershipService 应落地 markMembershipOrderFailed 支付失败回滚入口")
+    void paymentFailureRollback_contractMethod_landed() {
+        assertTrue(hasMethod(MembershipService.class, "markMembershipOrderFailed", 1),
+                KEY + " MembershipService 未落地 markMembershipOrderFailed(orderNo) 契约方法:"
+                        + "支付失败时需显式回滚订单(置失败态、不置 paid、不生成会员记录,重复调用幂等)"
+                        + "(SC-P-58 边界:支付失败回滚)。");
+    }
+
+    @Test
+    @DisplayName("边界流-4:支付回调开通失败时订单状态必须回滚,不得停留 paid 半态")
+    void paymentCallback_activationFailed_orderMustRollback() {
+        PaymentOrder order = pendingOrder("MO_PLAN_001");
+        when(paymentOrderMapper.selectOne(any(Wrapper.class))).thenReturn(order);
+        // 家庭无关联用户 → 会员开通失败(activateMembership 返回 false)
+        when(familyMapper.selectById(5L)).thenReturn(null);
+        when(userMapper.selectList(any(Wrapper.class))).thenReturn(Collections.emptyList());
+
+        boolean ok = service.processPaymentCallback("MO_PLAN_001", "wx_tx_fail", "wechat");
+
+        assertFalse(ok, KEY + " 开通失败时回调应返回 false");
+        assertEquals("pending", order.getStatus(),
+                KEY + " 支付失败回滚:回调开通失败后订单必须回滚(不置 paid),"
+                        + "当前实现先置 paid 再开通、失败不回滚 → 遗留“订单 paid 但无会员记录”半态"
+                        + "(SC-P-58 边界:支付失败回滚)。");
+    }
+
+    // ==================== 权限流:无家庭 → 购买入口拒绝(fail-fast) ====================
+
+    @Test
+    @DisplayName("权限流-1:无家庭(familyId=null)时购买入口必须最先拒绝")
+    void permissionFlow_noFamily_purchaseRejected() {
+        // 契约:purchasePlan 在触碰任何数据前最先校验家庭上下文(与 createOrder 既有文案同源)。
+        Object host = contractHost("purchasePlan", 5);
+        RuntimeException ex = assertThrows(RuntimeException.class,
+                () -> call(host, "purchasePlan", 1L, null, "FAMILY", "yearly", null));
+        assertTrue(ex.getMessage().contains("家庭"),
+                KEY + " 无家庭购买必须拒绝并提示家庭上下文:实际 " + ex.getMessage());
+    }
+
+    // ==================== 辅助构造 ====================
+
+    private MembershipLevel familyLevel() {
+        MembershipLevel l = new MembershipLevel();
+        l.setId(3L);
+        l.setLevelCode("FAMILY");
+        l.setLevelName("家庭版");
+        l.setLevelOrder(3);
+        l.setPriceYearly(39800);
+        return l;
+    }
+
+    private FamilyMembership activeMembership(String levelCode) {
+        FamilyMembership m = new FamilyMembership();
+        m.setId(1L);
+        m.setFamilyId(5L);
+        m.setLevelCode(levelCode);
+        m.setPaymentStatus("paid");
+        m.setStartDate(new Date(System.currentTimeMillis() - 86400000L));
+        m.setEndDate(new Date(System.currentTimeMillis() + 30L * 86400000L));
+        return m;
+    }
+
+    private PaymentOrder pendingOrder(String orderNo) {
+        PaymentOrder o = new PaymentOrder();
+        o.setId(1L);
+        o.setOrderNo(orderNo);
+        o.setFamilyId(5L);
+        o.setLevelCode("FAMILY");
+        o.setPaymentType("wechat");
+        o.setPeriod("yearly");
+        o.setAmount(39800);
+        o.setStatus("pending");
+        o.setPeriodNo(1);
+        o.setCreatedAt(new Date());
+        return o;
+    }
+
+    // ==================== 反射辅助(锚定契约宿主方法,避免编译期依赖不存在方法) ====================
+
+    private static boolean hasMethod(Class<?> clazz, String name, int paramCount) {
+        for (Method m : clazz.getDeclaredMethods()) {
+            if (m.getName().equals(name) && m.getParameterCount() == paramCount) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private Object contractHost(String method, int arity) {
+        assertTrue(hasMethod(MembershipService.class, method, arity),
+                KEY + " 契约方法 MembershipService#" + method + "(...) 未实现(能力键实现未落地,GREEN 阶段按 javadoc 签名落地)。");
+        return new MembershipService();
+    }
+
+    /** 按方法名 + 参数个数匹配并调用;被调方法抛出的 RuntimeException 原样上抛(供 assertThrows 断言)。 */
+    private Object call(Object host, String method, Object... args) {
+        for (Method m : host.getClass().getDeclaredMethods()) {
+            if (m.getName().equals(method) && m.getParameterCount() == args.length) {
+                try {
+                    return m.invoke(host, args);
+                } catch (InvocationTargetException e) {
+                    Throwable cause = e.getCause();
+                    if (cause instanceof RuntimeException) {
+                        throw (RuntimeException) cause;
+                    }
+                    if (cause instanceof Error) {
+                        throw (Error) cause;
+                    }
+                    fail(KEY + " 契约方法 " + method + " 调用异常:" + cause);
+                    throw new IllegalStateException("unreachable");
+                } catch (Exception e) {
+                    fail(KEY + " 契约方法 " + method + " 调用失败:" + e.getMessage());
+                    throw new IllegalStateException("unreachable");
+                }
+            }
+        }
+        fail(KEY + " 契约方法 MembershipService#" + method + " 未实现(按 javadoc 签名落地)");
+        throw new IllegalStateException("unreachable");
+    }
+}