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

Merge branch 'task/S-cfc-304' (S-cfc-304 energy.ruleEngine.apply 补强 SC-P-90/SC-P-93 RED 契约)

Sisyphus 4 дней назад
Родитель
Сommit
0fa936f1c5

+ 248 - 4
cfc-backend/src/test/java/com/etotem/cfc/unit/EnergyRuleEngineApplyContractTest.java

@@ -1,10 +1,14 @@
 package com.etotem.cfc.unit;
 
+import com.baomidou.mybatisplus.core.conditions.AbstractWrapper;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+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.EnergyRule;
 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;
@@ -21,14 +25,19 @@ import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentCaptor;
 
+import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.text.SimpleDateFormat;
 import java.util.Arrays;
+import java.util.Calendar;
 import java.util.Collections;
+import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
@@ -36,6 +45,7 @@ import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.atMost;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
@@ -78,6 +88,8 @@ import static org.mockito.Mockito.when;
  *       将任务类型映射到的维度增加 amount」不成立);</li>
  *   <li><b>文章互动归因(SC-P-93/ED-7)</b>:{@code eventType=article} 规则声明 {@code dimensionCode=mind} 时
  *       写 mind 维度——当前同样回落 action(行为断言);</li>
+ *   <li><b>活动参与归因(SC-P-93/ED-7 第 2 类触发源)</b>:{@code eventType=activity} 规则声明
+ *       {@code dimensionCode=wisdom} 时写 wisdom 维度——当前同样回落 action(行为断言);</li>
  *   <li><b>同源重复触发幂等(SC-P-87 边界/ED-1)</b>:同一 {@code (memberId, sourceType=task, sourceId)}
  *       重复触发(重复审批/网络重试)只写一次 {@code EnergyLog}——当前 {@code evaluate} 每次直接 award,
  *       无写路径幂等(行为断言;schema 侧幂等唯一键由 S-cfc-225 覆盖);</li>
@@ -88,21 +100,44 @@ import static org.mockito.Mockito.when;
  *   <li><b>余额不足可感知拒绝(SC-P-88-E-1/ED-2)</b>:decrease 规则在余额不足时应向调用方暴露拒绝
  *       (异常/结果标记「能量不足」),不得静默忽略 {@code deductEnergy} 的 -1——当前 {@code evaluate}
  *       忽略返回且不抛错(余额不为负本身由 {@code EnergyService.deductEnergy} 保证,本键锚调用方可感知性)。</li>
+ *   <li><b>日上限配置驱动(SC-P-90 前置/ED-4)</b>:{@link EnergyRuleEngine} 应注入
+ *       {@link DimensionDailyLimitMapper},按 {@code energy_daily_limit} 配置({@code DimensionDailyLimit})
+ *       判定单维度日上限——当前引擎无该注入点,写路径只能落到 {@code EnergyService} 的硬编码
+ *       {@code DAILY_LIMIT_MAP}(配置变更对规则触发不生效);</li>
+ *   <li><b>单维度触顶不再累加(SC-P-90 主流程 2/ED-4)</b>:配置 {@code body dailyLimit=10}、当日累计 8、
+ *       规则 +5(8+5&gt;10)→ 触顶,写路径不得新增 {@code EnergyLog}——当前配置不参与判定(硬编码 body=50)
+ *       → 照常写入(行为断言);</li>
+ *   <li><b>多来源共享日上限(SC-P-90-E-1/ED-4)</b>:task 来源当日已把 body 累计打到 10(触顶),
+ *       article 来源同维度再触发同样受限、不写流水——多来源共享同一日上限(行为断言);</li>
+ *   <li><b>上限 0/负不崩溃(SC-P-90-E-4/ED-4)</b>:配置 {@code dailyLimit=0} 按 0 处理(不再累加)
+ *       且不得崩溃——当前未读取配置 → 照常写入(行为断言 + 不抛异常);</li>
  * </ul>
  *
  * <p><b>正常流锚点(已实现 → 绿,如实记录非 RED)</b></p>
  * <ul>
  *   <li>无匹配规则的事件:{@code evaluate} 直接返回、不写任何流水;</li>
- *   <li>归因写入的流水承载 {@code sourceType=task}/{@code sourceId=任务实例ID}(/api/energy/logs 写盘依据)。</li>
+ *   <li>归因写入的流水承载 {@code sourceType=task}/{@code sourceId=任务实例ID}(/api/energy/logs 写盘依据);</li>
+ *   <li><b>次日重置 / 跨时区以服务端日期为准(SC-P-90 主流程 3 + 异常边界)</b>:写路径的日累计查询以服务端
+ *       「今日 00:00:00–23:59:59.999」窗口绑定 {@code energy_log.created_at}({@code between}),窗口随服务端
+ *       日期前移 → 昨日流水不计入今日累计、客户端时钟不可绕过(wrapper 参数断言,当前已生效)。</li>
  * </ul>
  *
  * <p><b>权限流(TC-P-87-P/88-P/90-P/93-P)</b>:跨角色/跨家庭能量访问 403 由
  * {@link EnergyIsolationContractTest}(数据隔离)覆盖、日上限配置越权由
  * {@link EnergyConfigAdminContractTest}(admin 守卫)覆盖,本键为内部触发写入路径,权限流不适用(说明性)。</p>
  *
- * <p><b>RED 预期</b>:8 条契约缺口断言失败(红,失败原文含 {@code RED[energy.ruleEngine.apply] …})、
- * 2 条正常流锚点通过(绿)、1 条权限流标注(绿,说明性)。GREEN 阶段按 SC-P-87/88/90/93 落地
- * {@code apply}(public 入口 + 可观测结果 + 规则归因生效 + 写路径幂等 + 异常告警传播 + 扣减拒绝感知)后自动转绿。</p>
+ * <p><b>RED 预期</b>:13 条契约缺口断言失败(红,失败原文含 {@code RED[energy.ruleEngine.apply] …})、
+ * 3 条正常流锚点通过(绿)、1 条权限流标注(绿,说明性)。GREEN 阶段按 SC-P-87/88/90/93 落地
+ * {@code apply}(public 入口 + 可观测结果 + 规则归因生效 + 写路径幂等 + 异常告警传播 + 扣减拒绝感知
+ * + {@code DimensionDailyLimit} 配置驱动日上限 + 多来源共享触顶 + 0/负安全)后自动转绿。</p>
+ *
+ * <p><b>版本增补(v2,SC-P-90/SC-P-93 覆盖补强)</b>:v1(commit {@code 62d0240ff} 已合入主链,
+ * 8 RED + 3 绿)覆盖 apply 入口/可观测/归因/幂等/告警/扣减拒绝,但 SC-P-90({@code DimensionDailyLimit}
+ * 日上限)仅作为「apply 结果应可观测触顶」的附属断言出现,缺写路径端到端覆盖。v2 在隔离 worktree 增补
+ * 5 条 RED(引擎日上限配置注入 / 单维度触顶不累加 / 多来源共享触顶 / 上限 0·负不崩溃 /
+ * 活动参与归因)+ 1 条 GREEN 锚点(次日重置·服务端日期窗口),使 SC-P-87/88/90/93 四场景在本键均有
+ * 写路径断言。与 {@code energy.dailyLimit.guard}(S-cfc-306,服务侧 public 守卫入口 + 配置驱动)互补:
+ * 本键只锚「规则触发 → 写路径」的触顶行为,不重复守卫入口结构断言。</p>
  *
  * <p><b>测试范围</b>:纯 Mockito / 无 Spring 上下文 / 无 DB / 无外部服务;直接实例化
  * {@link EnergyRuleEngine} 注入 mock {@link EnergyRuleMapper}/{@link EnergyDimensionMapper},并把
@@ -121,6 +156,9 @@ class EnergyRuleEngineApplyContractTest extends EnergyContractTestBase {
     private static final Long MEMBER_ID = 50L;
     private static final Long TASK_ID = 100L;
 
+    /** 日上限配置实体/Mapper(SC-P-90 前置:energy_daily_limit) */
+    private static final String DIMENSION_DAILY_LIMIT_MAPPER = "com.etotem.cfc.mapper.DimensionDailyLimitMapper";
+
     private EnergyRuleEngine engine;
     private EnergyService service;
 
@@ -243,6 +281,26 @@ class EnergyRuleEngineApplyContractTest extends EnergyContractTestBase {
                         + ",文章互动归因维度未生效(SC-P-93 缺口)。");
     }
 
+    @Test
+    @DisplayName("RED:活动参与事件规则声明归因维度 wisdom → EnergyLog 应写 wisdom 维度(SC-P-93/ED-7)")
+    void RED_归因_活动参与规则写wisdom维度() {
+        // SC-P-93 第 2 类触发源:报名/参与平台活动 → 按规则加对应维度能量
+        EnergyRule rule = rule(9L, "activity", "increase", "wisdom", 3, 1);
+        when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
+        when(dimensionMapper.selectOne(any())).thenReturn(dim(1L, "wisdom", "智慧", "金"));
+
+        engine.evaluate("activity", 400L, MEMBER_ID, new HashMap<>());
+
+        List<EnergyLog> written = captureInsertedLogs();
+        boolean wroteWisdom = written.stream().anyMatch(l ->
+                l.getDimensionId() != null && l.getDimensionId().longValue() == 1L);
+        assertTrue(wroteWisdom,
+                "RED[energy.ruleEngine.apply]:活动参与事件(SC-P-93/ED-7 主流程 1『…报名参与活动 → 触发"
+                        + " EnergyRuleEngine 对应维度 +amount』)规则声明归因维度 wisdom(id=1),应写入 wisdom 维度;"
+                        + "当前回落默认 action(id=3)维度,实际写入 dimensionId=" + written.get(0).getDimensionId()
+                        + ",活动参与归因维度未生效(SC-P-93 缺口)。");
+    }
+
     // ==================== RED-5:同源重复触发幂等(SC-P-87 边界/ED-1) ====================
 
     @Test
@@ -316,8 +374,129 @@ class EnergyRuleEngineApplyContractTest extends EnergyContractTestBase {
                         + " deductEnergy 的 -1 返回值;当前 evaluate 忽略扣减返回且不抛错,兑换侧无法感知『能量不足』。");
     }
 
+    // ==================== RED-9~12:日上限 DailyLimit 写路径(SC-P-90/ED-4) ====================
+
+    @Test
+    @DisplayName("RED:EnergyRuleEngine 应注入 DimensionDailyLimitMapper(日上限配置驱动,SC-P-90 前置)")
+    void RED_日上限_引擎配置驱动注入() {
+        boolean hasMapper = false;
+        for (Field f : EnergyRuleEngine.class.getDeclaredFields()) {
+            if (DIMENSION_DAILY_LIMIT_MAPPER.equals(f.getType().getName())) {
+                hasMapper = true;
+                break;
+            }
+        }
+        assertTrue(hasMapper,
+                "RED[energy.ruleEngine.apply]:EnergyRuleEngine 应注入 DimensionDailyLimitMapper,按"
+                        + " energy_daily_limit 配置(DimensionDailyLimit.dailyLimit)判定实时触发写入的单维度日上限"
+                        + "(SC-P-90 前置『DimensionDailyLimit 已配置某维度 dailyLimit=N』/ED-4)。当前引擎无该注入点,"
+                        + "写路径只能落到 EnergyService 的硬编码 DAILY_LIMIT_MAP(body=50 等)→ 运营改配置对规则触发不生效。");
+    }
+
+    @Test
+    @DisplayName("RED:单维度当日累计触顶后不再累加(SC-P-90 主流程 2)")
+    void RED_日上限_触顶不再累加() {
+        bindDailyLimit("body", 10);
+        // 当日 body 已累计 8(来自 checkin 来源),规则再 +5 → 8+5 > 10 触顶
+        when(logMapper.selectList(any())).thenReturn(Collections.singletonList(
+                energyLog(1L, MEMBER_ID, 5L, 8, 8, "checkin", 900L)));
+        EnergyRule rule = rule(10L, "task", "increase", "body", 5, 1);
+        when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
+        when(dimensionMapper.selectOne(any())).thenReturn(dim(5L, "body", "身体", "土"));
+
+        engine.evaluate("task", TASK_ID, MEMBER_ID, new HashMap<>());
+
+        List<EnergyLog> written = captureInsertedLogsOrEmpty();
+        String actual = written.isEmpty() ? "0 条" : written.size() + " 条(dimensionId="
+                + written.get(0).getDimensionId() + ",amount=" + written.get(0).getAmount() + ")";
+        assertTrue(written.isEmpty(),
+                "RED[energy.ruleEngine.apply]:配置 body dailyLimit=10、当日已累计 8(checkin 来源),规则再 +5"
+                        + "(8+5>10)→ 触顶,写路径不得新增 EnergyLog(SC-P-90 主流程 2『累计达 dailyLimit 后新增触发"
+                        + "不再累加』/ED-4)。当前引擎未读取 DimensionDailyLimit 配置,仅落到硬编码 body=50 → 本次照常写入 "
+                        + actual + "。");
+    }
+
+    @Test
+    @DisplayName("RED:多来源共享同一日上限 — task 触顶后 article 同维度同样受限(SC-P-90-E-1)")
+    void RED_日上限_多来源共享触顶() {
+        bindDailyLimit("body", 10);
+        // 当日 body 已累计 10(task 来源已触顶),article 来源再触发 +5 → 多来源共享同一日上限 → 不得累加
+        when(logMapper.selectList(any())).thenReturn(Collections.singletonList(
+                energyLog(2L, MEMBER_ID, 5L, 10, 10, "task", TASK_ID)));
+        EnergyRule rule = rule(11L, "article", "increase", "body", 5, 1);
+        when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
+        when(dimensionMapper.selectOne(any())).thenReturn(dim(5L, "body", "身体", "土"));
+
+        engine.evaluate("article", 200L, MEMBER_ID, new HashMap<>());
+
+        List<EnergyLog> written = captureInsertedLogsOrEmpty();
+        assertTrue(written.isEmpty(),
+                "RED[energy.ruleEngine.apply]:多来源(任务+打卡+活动)共享同一日上限——当日 body 已由 task 来源累计到"
+                        + " 10(配置 dailyLimit=10)触顶,article 来源同维度再触发 +5 应同样受限、不写流水"
+                        + "(SC-P-90-E-1『任一来源达成后其余来源同维度均受限』/ED-4)。当前配置不参与判定 → 本次照常写入 "
+                        + written.size() + " 条。");
+    }
+
+    @Test
+    @DisplayName("RED:上限 0/负不崩溃 — 配置 dailyLimit=0 按 0 处理不累加(SC-P-90-E-4)")
+    void RED_日上限_零负不崩溃() {
+        bindDailyLimit("body", 0);
+        EnergyRule rule = rule(12L, "task", "increase", "body", 10, 1);
+        when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
+        when(dimensionMapper.selectOne(any())).thenReturn(dim(5L, "body", "身体", "土"));
+
+        assertDoesNotThrow(() -> engine.evaluate("task", TASK_ID, MEMBER_ID, new HashMap<>()),
+                "SC-P-90-E-4:日上限配置为 0/负不得崩溃(NPE/除零/负数异常),应按 0 处理。");
+
+        List<EnergyLog> written = captureInsertedLogsOrEmpty();
+        assertTrue(written.isEmpty(),
+                "RED[energy.ruleEngine.apply]:配置 body dailyLimit=0(SC-P-90-E-4『日上限配置为 0 或负数:拒绝配置或"
+                        + "按 0 处理,不得崩溃』)→ 按 0 处理、不再累加,写路径不得新增 EnergyLog。当前引擎未读取配置"
+                        + " → 本次照常写入 " + written.size() + " 条。");
+    }
+
     // ==================== 正常流锚点(已实现 → 绿,如实记录非 RED) ====================
 
+    @Test
+    @DisplayName("GREEN anchor:次日重置/跨时区 — 日累计查询绑定服务端今日窗口(SC-P-90 主流程 3)")
+    void GREEN_日上限_次日重置服务端窗口() {
+        // SC-P-90 主流程 3 + 异常边界:跨日 00:00 累计清零,时钟/跨时区以服务端日期为准(不接收客户端时间入参)。
+        // 写路径的日累计查询必须把 energy_log.created_at 绑定到服务端「今日 00:00:00–23:59:59.999」窗口,
+        // 窗口随服务端日期前移 → 昨日流水不计入今日累计(当前已生效,非 RED)。
+        EnergyRule rule = rule(13L, "task", "increase", "body", 1, 1);
+        when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
+        when(dimensionMapper.selectOne(any())).thenReturn(dim(5L, "body", "身体", "土"));
+
+        engine.evaluate("task", TASK_ID, MEMBER_ID, new HashMap<>());
+
+        Date todayStart = serverTodayStart();
+        Date todayEnd = serverTodayEnd();
+        SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
+        boolean windowBound = false;
+        for (Wrapper w : captureLogQueryWrappers()) {
+            if (!(w instanceof AbstractWrapper)) continue;
+            AbstractWrapper<?, ?, ?> wrapper = (AbstractWrapper<?, ?, ?>) w;
+            // MP 的参数值在 SQL 片段求值时写入 paramNameValuePairs → 先触发 getSqlSegment()
+            String sqlSegment = wrapper.getSqlSegment();
+            if (sqlSegment == null || !sqlSegment.contains("created_at")) continue;
+            boolean hasStart = false;
+            boolean hasEnd = false;
+            for (Object v : wrapper.getParamNameValuePairs().values()) {
+                if (!(v instanceof Date)) continue;
+                if (((Date) v).getTime() == todayStart.getTime()) hasStart = true;
+                if (((Date) v).getTime() == todayEnd.getTime()) hasEnd = true;
+            }
+            if (hasStart && hasEnd) {
+                windowBound = true;
+                break;
+            }
+        }
+        assertTrue(windowBound,
+                "GREEN anchor[energy.ruleEngine.apply]:日上限累计查询应把 created_at 绑定到服务端今日窗口 ["
+                        + fmt.format(todayStart) + ", " + fmt.format(todayEnd) + "](SC-P-90 主流程 3 次日重置 /"
+                        + " 异常边界『以服务端日期为准』)。未捕获到带今日窗口参数的查询 → 跨日累计不会归零。");
+    }
+
     @Test
     @DisplayName("GREEN anchor:无匹配规则的事件不写任何流水")
     void GREEN_无规则不写流水() {
@@ -375,6 +554,71 @@ class EnergyRuleEngineApplyContractTest extends EnergyContractTestBase {
         return captor.getAllValues();
     }
 
+    /** 捕获 insert 参数(允许 0 条,用于「不应写入」断言) */
+    private List<EnergyLog> captureInsertedLogsOrEmpty() {
+        ArgumentCaptor<EnergyLog> captor = ArgumentCaptor.forClass(EnergyLog.class);
+        verify(logMapper, atMost(5)).insert(captor.capture());
+        return captor.getAllValues();
+    }
+
+    /** 捕获日累计/流水查询的 wrapper(用于校验服务端今日窗口绑定) */
+    @SuppressWarnings("unchecked")
+    private List<Wrapper> captureLogQueryWrappers() {
+        ArgumentCaptor<Wrapper> captor = ArgumentCaptor.forClass(Wrapper.class);
+        verify(logMapper, atLeastOnce()).selectList(captor.capture());
+        return captor.getAllValues();
+    }
+
+    /**
+     * 绑定引擎侧日上限配置(SC-P-90 前置:DimensionDailyLimit 配 dailyLimit=N)。
+     * 当前 {@link EnergyRuleEngine} 缺 {@code dimensionDailyLimitMapper} 注入点 → 直接 RED 失败并给出契约原文。
+     */
+    private void bindDailyLimit(String dimensionCode, int dailyLimit) {
+        DimensionDailyLimitMapper dailyLimitMapper = mock(DimensionDailyLimitMapper.class);
+        try {
+            inject(engine, "dimensionDailyLimitMapper", dailyLimitMapper);
+        } catch (NoSuchFieldException e) {
+            fail("RED[energy.ruleEngine.apply] precondition:EnergyRuleEngine 缺 dimensionDailyLimitMapper 注入点"
+                    + "(NoSuchFieldException),无法按 energy_daily_limit 配置判定单维度日上限"
+                    + "(SC-P-90 前置『DimensionDailyLimit 已配置某维度 dailyLimit=" + dailyLimit + "』)。");
+            return;
+        } catch (Exception e) {
+            fail("RED[energy.ruleEngine.apply] precondition:注入 dimensionDailyLimitMapper 失败:"
+                    + e.getClass().getSimpleName() + " " + e.getMessage());
+            return;
+        }
+
+        initTable(DimensionDailyLimit.class);
+        DimensionDailyLimit config = new DimensionDailyLimit();
+        config.setId(1L);
+        config.setDimensionCode(dimensionCode);
+        config.setDailyLimit(dailyLimit);
+        config.setCreatedAt(new Date());
+        config.setUpdatedAt(new Date());
+        when(dailyLimitMapper.selectList(any())).thenReturn(Collections.singletonList(config));
+        when(dailyLimitMapper.selectOne(any())).thenReturn(config);
+    }
+
+    /** 服务端今日 00:00:00.000(与业务侧 getTodayStart 同口径:JVM 服务端时钟) */
+    private static Date serverTodayStart() {
+        Calendar cal = Calendar.getInstance();
+        cal.set(Calendar.HOUR_OF_DAY, 0);
+        cal.set(Calendar.MINUTE, 0);
+        cal.set(Calendar.SECOND, 0);
+        cal.set(Calendar.MILLISECOND, 0);
+        return cal.getTime();
+    }
+
+    /** 服务端今日 23:59:59.999(与业务侧 getTodayEnd 同口径) */
+    private static Date serverTodayEnd() {
+        Calendar cal = Calendar.getInstance();
+        cal.set(Calendar.HOUR_OF_DAY, 23);
+        cal.set(Calendar.MINUTE, 59);
+        cal.set(Calendar.SECOND, 59);
+        cal.set(Calendar.MILLISECOND, 999);
+        return cal.getTime();
+    }
+
     /** 规则构造(status=1 active,conditions 空 → 无条件匹配) */
     private static EnergyRule rule(Long id, String eventType, String action, String dimCode,
                                    Integer amount, int priority) {