浏览代码

test(contract): S-cfc-306 energy.dailyLimit.guard TDD-RED 契约单测

能力键 energy.dailyLimit.guard(SC-P-90 五维每日获取上限 DailyLimit,TDD-RED 阶段)。
预期红(RED)契约测试,未改 src/main 实现。

契约锚点(TC-P-90 / -E / -P + ED-4 + API_REFERENCE DimensionDailyLimit 模块,
与 S-cfc-304 ruleEngine.apply 同链:ruleEngine 写入前经 daily limit 守卫校验):
- RED 守卫入口:EnergyService 应提供 public 每日上限守卫方法(当前 isDailyLimitExceeded 为 private)
- RED 守卫钩子:EnergyRuleEngine 应有 daily-limit 守卫钩子(ruleEngine 写入前校验)
- RED 配置驱动:EnergyService 应注入 DimensionDailyLimitMapper 读取 energy_daily_limit(当前硬编码 DAILY_LIMIT_MAP)
- RED 多来源共享:awardEnergyByCode(challenge 来源)绕过日上限(TC-P-90-E-1)
- RED 上限 0/负安全:配置 dailyLimit=0 应按 0 处理不发不崩溃(TC-P-90-E-4)

实测:Tests run 8, Failures 5(红)/ 通过 3(2 正常流锚点 + 1 权限流标注不适用)。
zxyj-langgraph 2 天之前
父节点
当前提交
bf1c4fc8f5
共有 1 个文件被更改,包括 280 次插入 和 0 次删除
  1. 280 0
      cfc-backend/src/test/java/com/etotem/cfc/unit/EnergyDailyLimitGuardContractTest.java

+ 280 - 0
cfc-backend/src/test/java/com/etotem/cfc/unit/EnergyDailyLimitGuardContractTest.java

@@ -0,0 +1,280 @@
+package com.etotem.cfc.unit;
+
+import com.etotem.cfc.entity.DimensionDailyLimit;
+import com.etotem.cfc.entity.EnergyBalance;
+import com.etotem.cfc.entity.EnergyDimension;
+import com.etotem.cfc.entity.EnergyLog;
+import com.etotem.cfc.entity.FamilyMember;
+import com.etotem.cfc.mapper.DimensionDailyLimitMapper;
+import com.etotem.cfc.mapper.EnergyBalanceMapper;
+import com.etotem.cfc.mapper.EnergyBehaviorConfigMapper;
+import com.etotem.cfc.mapper.EnergyDimensionMapper;
+import com.etotem.cfc.mapper.EnergyLogMapper;
+import com.etotem.cfc.mapper.EnergySourceConfigMapper;
+import com.etotem.cfc.mapper.FamilyMemberMapper;
+import com.etotem.cfc.service.EnergyRuleEngine;
+import com.etotem.cfc.service.EnergyService;
+import com.etotem.cfc.service.NotificationDispatchService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.Map;
+
+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 energy.dailyLimit.guard}(任务 S-cfc-306,TDD-RED 阶段)契约级单测。
+ *
+ * <p><b>需求/设计溯源</b></p>
+ * <ul>
+ *   <li>需求:{@code tests/user-scenarios/应用场景总览.md} SC-P-90(五维每日获取上限 DailyLimit)
+ *       + {@code tests/user-scenarios/07-five-dimension.md} 场景 ED-4(单维度单日累计触顶后不再累加、
+ *       次日重置;多来源共享日上限;手动是否计入需断言一致;跨时区以服务端日期为准;上限 0/负不崩溃);
+ *       契约条款 {@code tests/test-cases/parent.md} TC-P-90 / TC-P-90-E / TC-P-90-P。</li>
+ *   <li>设计:{@code docs/superpowers/api/API_REFERENCE.md} 模块 {@code DimensionDailyLimit} /
+ *       {@code EnergyController};与 {@code energy.ruleEngine.apply}(S-cfc-304)同链:
+ *       <b>ruleEngine 写入前经 daily limit 守卫校验</b>(SC-P-90 设计锚点)。</li>
+ * </ul>
+ *
+ * <p><b>被校验的契约行为(TDD-RED 锚点,当前实现未落地 → 红)</b></p>
+ * <ul>
+ *   <li><b>守卫入口(SC-P-90 设计:ruleEngine 写入前经守卫校验)</b>:{@link EnergyService} 应提供
+ *       <b>public</b> 每日上限守卫方法(命名含 {@code guard/isAllowed/checkDailyLimit})——
+ *       当前 {@code isDailyLimitExceeded} 为 private,无 public 守卫入口(反射结构探测);</li>
+ *   <li><b>守卫钩子(S-cfc-304 同链)</b>:{@link EnergyRuleEngine} 应有 daily-limit 守卫钩子方法,
+ *       {@code evaluate} 写入前调用——当前无任何 guard 方法(反射结构探测);</li>
+ *   <li><b>配置驱动(TC-P-90 前置)</b>:{@link EnergyService} 应注入 {@link DimensionDailyLimitMapper}
+ *       读取 {@code energy_daily_limit} 配置驱动上限——当前无该字段,使用硬编码
+ *       {@code DAILY_LIMIT_MAP}(反射结构探测);</li>
+ *   <li><b>多来源共享日上限(TC-P-90-E-1)</b>:{@code awardEnergyByCode}(challenge 来源)应受日上限
+ *       约束——当前直接 {@code executeAward} 绕过(行为断言);</li>
+ *   <li><b>上限 0/负安全(TC-P-90-E-4)</b>:配置 {@code dailyLimit=0/负} 应按 0 处理不发且不崩溃——
+ *       当前未读取配置(行为断言)。</li>
+ * </ul>
+ *
+ * <p><b>正常流锚点(已实现 → 绿,如实记录非 RED)</b></p>
+ * <ul>
+ *   <li>硬编码单维度上限({@code body=50})当日累计触顶后 {@code grantEnergy} 再发 → 抛
+ *       {@link IllegalStateException}(超限拦截已生效);</li>
+ *   <li>手动 grant 口径 = 计入日上限({@code grantEnergy} 调用 {@code isDailyLimitExceeded})。</li>
+ * </ul>
+ *
+ * <p><b>权限流(TC-P-90-P)</b>:本能力为内部服务守卫(ruleEngine→award 写入前的校验钩子),
+ * 无用户权限维度;「查 F9 成员日上限累计 403 / 越权改配置 403」由
+ * {@link EnergyIsolationContractTest} 与 {@link EnergyConfigAdminContractTest}(admin 守卫)覆盖,
+ * 本类标注「不适用」。</p>
+ *
+ * <p><b>RED 预期</b>:5 条契约缺口断言失败(红)、2 条正常流锚点通过(绿)、1 条权限流标注(通过);
+ * 失败原文含 {@code RED[energy.dailyLimit.guard] …}。GREEN 阶段按 SC-P-90 设计落地
+ * (public 守卫 + {@code DimensionDailyLimitMapper} 配置驱动 + 多来源一致 + 0/负安全)后自动转绿。</p>
+ *
+ * <p><b>测试范围</b>:纯 Mockito / 无 Spring 上下文 / 无 DB / 无外部服务;直接实例化
+ * {@link EnergyService} 并注入 mock,反射结构探测 + 行为断言(复用
+ * {@link EnergyContractTestBase#inject}/{@link EnergyContractTestBase#initTable}/
+ * {@link EnergyContractTestBase#fiveDims}/{@link EnergyContractTestBase#energyLog})。</p>
+ */
+class EnergyDailyLimitGuardContractTest extends EnergyContractTestBase {
+
+    private static final Long MEMBER_ID = 50L;
+    private static final Long BODY_DIM_ID = 5L;
+    private static final String BODY_CODE = "body";
+
+    private EnergyService service;
+
+    private EnergyDimensionMapper dimensionMapper;
+    private EnergyBehaviorConfigMapper behaviorConfigMapper;
+    private EnergyLogMapper logMapper;
+    private EnergyBalanceMapper balanceMapper;
+    private FamilyMemberMapper familyMemberMapper;
+    private EnergySourceConfigMapper sourceConfigMapper;
+
+    @BeforeEach
+    void setUp() throws Exception {
+        service = new EnergyService();
+        dimensionMapper = mock(EnergyDimensionMapper.class);
+        behaviorConfigMapper = mock(EnergyBehaviorConfigMapper.class);
+        logMapper = mock(EnergyLogMapper.class);
+        balanceMapper = mock(EnergyBalanceMapper.class);
+        familyMemberMapper = mock(FamilyMemberMapper.class);
+        sourceConfigMapper = mock(EnergySourceConfigMapper.class);
+
+        inject(service, "energyDimensionMapper", dimensionMapper);
+        inject(service, "energyBehaviorConfigMapper", behaviorConfigMapper);
+        inject(service, "energyLogMapper", logMapper);
+        inject(service, "energyBalanceMapper", balanceMapper);
+        inject(service, "familyMemberMapper", familyMemberMapper);
+        inject(service, "energySourceConfigMapper", sourceConfigMapper);
+        inject(service, "notificationDispatchService", mock(NotificationDispatchService.class));
+        inject(service, "wishMapper", mock(com.etotem.cfc.mapper.WishMapper.class));
+
+        when(dimensionMapper.selectList(any())).thenReturn(Arrays.asList(fiveDims()));
+        when(behaviorConfigMapper.selectOne(any())).thenReturn(null);
+        when(logMapper.selectList(any())).thenReturn(Collections.emptyList());
+        when(balanceMapper.selectOne(any())).thenReturn(null);
+
+        FamilyMember member = new FamilyMember();
+        member.setId(MEMBER_ID);
+        member.setUserId(12L);
+        when(familyMemberMapper.selectById(any())).thenReturn(member);
+
+        initTable(EnergyDimension.class);
+        initTable(EnergyLog.class);
+        initTable(EnergyBalance.class);
+    }
+
+    // ==================== RED:守卫入口(SC-P-90 设计,ruleEngine 写入前经守卫校验) ====================
+
+    @Test
+    @DisplayName("RED:EnergyService 应提供 public 每日上限守卫入口")
+    void RED_守卫入口_EnergyService_public() {
+        boolean hasPublicGuard = false;
+        for (Method m : EnergyService.class.getDeclaredMethods()) {
+            if (m.getName().matches("(?i).*(guard|isallowed|checkdaily|dailylimit).*")
+                    && Modifier.isPublic(m.getModifiers())) {
+                hasPublicGuard = true;
+                break;
+            }
+        }
+        assertTrue(hasPublicGuard,
+                "RED[energy.dailyLimit.guard]:EnergyService 应提供 public 每日上限守卫方法"
+                        + "(命名含 guard/isAllowed/checkDailyLimit),供 ruleEngine 写入前校验(SC-P-90 设计)。"
+                        + "当前 isDailyLimitExceeded 为 private,无 public 守卫入口。");
+    }
+
+    @Test
+    @DisplayName("RED:EnergyRuleEngine 应有 daily-limit 守卫钩子(S-cfc-304 同链)")
+    void RED_守卫钩子_EnergyRuleEngine() {
+        boolean hasGuard = false;
+        for (Method m : EnergyRuleEngine.class.getDeclaredMethods()) {
+            if (m.getName().matches("(?i).*(guard|dailylimit).*")) {
+                hasGuard = true;
+                break;
+            }
+        }
+        assertTrue(hasGuard,
+                "RED[energy.dailyLimit.guard]:EnergyRuleEngine 应有 daily-limit 守卫钩子方法"
+                        + "(ruleEngine 写入前经守卫校验,S-cfc-304 同链),当前无任何 guard 方法。");
+    }
+
+    // ==================== RED:配置驱动(TC-P-90 前置:DimensionDailyLimit 配 dailyLimit=N) ====================
+
+    @Test
+    @DisplayName("RED:EnergyService 应注入 DimensionDailyLimitMapper(配置驱动上限)")
+    void RED_配置驱动_dimensionDailyLimitMapper() {
+        boolean hasMapper = false;
+        for (Field f : EnergyService.class.getDeclaredFields()) {
+            if (f.getType().getName().equals("com.etotem.cfc.mapper.DimensionDailyLimitMapper")) {
+                hasMapper = true;
+                break;
+            }
+        }
+        assertTrue(hasMapper,
+                "RED[energy.dailyLimit.guard]:EnergyService 应注入 DimensionDailyLimitMapper"
+                        + "读取 energy_daily_limit 配置驱动上限(TC-P-90 前置:DimensionDailyLimit 配 dailyLimit=N)。"
+                        + "当前无该字段,使用硬编码 DAILY_LIMIT_MAP(body=50 等),配置变更不生效。");
+    }
+
+    // ==================== RED:多来源共享日上限(TC-P-90-E-1) ====================
+
+    @Test
+    @DisplayName("RED:多来源共享日上限 — challenge 来源 awardEnergyByCode 绕过日上限")
+    void RED_多来源共享_challenge绕过日上限() {
+        // 当日 body 累计=49(来自 checkin 来源),body 硬编码上限=50,再发 10 → 契约要求超限不发
+        EnergyLog todayCumulative = energyLog(1L, MEMBER_ID, BODY_DIM_ID, 49, 49, "checkin", 1L);
+        when(logMapper.selectList(any())).thenReturn(Arrays.asList(todayCumulative));
+
+        // awardEnergyByCode(challenge 来源)应受日上限约束(多来源共享同一日上限)
+        Map<String, Integer> result = service.awardEnergyByCode(MEMBER_ID, BODY_CODE, 10, "挑战奖励");
+
+        assertTrue(result.isEmpty(),
+                "RED[energy.dailyLimit.guard]:当日 body 累计=49(多来源共享),再发 10 → 超限不发,应返回空。"
+                        + "当前 awardEnergyByCode 绕过日上限直接 executeAward → 发放成功(多来源共享日上限缺口)。");
+        verify(logMapper, never()).insert(any(EnergyLog.class));
+    }
+
+    // ==================== RED:上限 0/负安全(TC-P-90-E-4) ====================
+
+    @Test
+    @DisplayName("RED:上限 0/负安全 — 配置 dailyLimit=0 应按 0 处理不发且不崩溃")
+    void RED_上限零负_按零处理() {
+        // 前置:EnergyService 缺 dimensionDailyLimitMapper 字段(配置驱动未落地)→ precondition RED
+        DimensionDailyLimitMapper dailyLimitMapper;
+        try {
+            dailyLimitMapper = mock(DimensionDailyLimitMapper.class);
+            inject(service, "dimensionDailyLimitMapper", dailyLimitMapper);
+            initTable(DimensionDailyLimit.class);
+        } catch (Exception e) {
+            fail("RED[energy.dailyLimit.guard] precondition:EnergyService 缺 dimensionDailyLimitMapper 字段"
+                    + "(" + e.getClass().getSimpleName() + "),无法注入配置读取"
+                    + "(TC-P-90-E-4:日上限配 0/负 拒绝配置或按 0 处理、不崩溃)。");
+            return;
+        }
+
+        // 配置 body dailyLimit=0 → 任何发放应被拦截(按 0 处理,不崩溃)
+        DimensionDailyLimit zeroLimit = new DimensionDailyLimit();
+        zeroLimit.setId(1L);
+        zeroLimit.setDimensionCode(BODY_CODE);
+        zeroLimit.setDailyLimit(0);
+        zeroLimit.setCreatedAt(new Date());
+        zeroLimit.setUpdatedAt(new Date());
+        when(dailyLimitMapper.selectList(any())).thenReturn(Arrays.asList(zeroLimit));
+
+        Map<String, Integer> result = service.awardEnergyByCode(MEMBER_ID, BODY_CODE, 10, "测试");
+
+        assertTrue(result.isEmpty(),
+                "RED[energy.dailyLimit.guard]:配置 dailyLimit=0 → 应按 0 处理不发,应返回空。"
+                        + "当前实现未读取配置 → 使用硬编码上限 → 放行(0/负安全缺口)。");
+    }
+
+    // ==================== 正常流锚点(已实现 → 绿,如实记录非 RED) ====================
+
+    @Test
+    @DisplayName("GREEN anchor:硬编码单维度上限生效 — body 累计触顶再发抛 IllegalStateException")
+    void GREEN_硬编码上限生效() {
+        // 当日 body 累计=50,body 硬编码上限=50,再发 5 → 超限抛异常(当前实现已生效)
+        EnergyLog todayCumulative = energyLog(1L, MEMBER_ID, BODY_DIM_ID, 50, 50, "task", 1L);
+        when(logMapper.selectList(any())).thenReturn(Arrays.asList(todayCumulative));
+
+        assertThrows(IllegalStateException.class, () ->
+                        service.grantEnergy(MEMBER_ID, 8888L, 5L, BODY_CODE),
+                "GREEN anchor:硬编码上限 body=50,当日累计≥50 再发 → 抛 IllegalStateException(当前实现已生效)。");
+    }
+
+    @Test
+    @DisplayName("GREEN anchor:手动 grant 口径 = 计入日上限")
+    void GREEN_手动grant口径计入() {
+        // grantEnergy 调用 isDailyLimitExceeded → 手动发放计入日上限(口径=计入,需与规则来源一致)
+        EnergyLog todayCumulative = energyLog(1L, MEMBER_ID, BODY_DIM_ID, 48, 48, "checkin", 1L);
+        when(logMapper.selectList(any())).thenReturn(Arrays.asList(todayCumulative));
+
+        // body 累计=48 + 5 = 53 > 50 → 抛异常(手动 grant 受限,口径=计入)
+        assertThrows(IllegalStateException.class, () ->
+                        service.grantEnergy(MEMBER_ID, 8888L, 5L, BODY_CODE),
+                "GREEN anchor:手动 grant 计入日上限(grantEnergy 调用 isDailyLimitExceeded)。");
+    }
+
+    // ==================== 权限流(不适用,说明性用例) ====================
+
+    @Test
+    @DisplayName("权限流:内部服务守卫,访问控制在 Controller 层,权限流不适用")
+    void 权限流_不适用() {
+        // 契约 AC 为「ruleEngine→award 写入前的 daily limit 守卫校验」内部链路,无用户权限维度。
+        // TC-P-90-P(查 F9 成员日上限累计 403 / 越权改配置 403)由 EnergyIsolationContractTest(数据隔离)
+        // 与 EnergyConfigAdminContractTest(admin 守卫 /daily-limit-save)覆盖,此处标注不适用。
+        assertTrue(true, "权限流不适用:energy.dailyLimit.guard 为内部服务守卫,无用户权限维度。");
+    }
+}