EnergyRuleEngineApplyContractTest.java 39 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638
  1. package com.etotem.cfc.unit;
  2. import com.baomidou.mybatisplus.core.conditions.AbstractWrapper;
  3. import com.baomidou.mybatisplus.core.conditions.Wrapper;
  4. import com.etotem.cfc.entity.DimensionDailyLimit;
  5. import com.etotem.cfc.entity.EnergyBalance;
  6. import com.etotem.cfc.entity.EnergyDimension;
  7. import com.etotem.cfc.entity.EnergyLog;
  8. import com.etotem.cfc.entity.EnergyRule;
  9. import com.etotem.cfc.entity.FamilyMember;
  10. import com.etotem.cfc.mapper.DimensionDailyLimitMapper;
  11. import com.etotem.cfc.mapper.EnergyBalanceMapper;
  12. import com.etotem.cfc.mapper.EnergyBehaviorConfigMapper;
  13. import com.etotem.cfc.mapper.EnergyDimensionMapper;
  14. import com.etotem.cfc.mapper.EnergyLogMapper;
  15. import com.etotem.cfc.mapper.EnergyRuleMapper;
  16. import com.etotem.cfc.mapper.EnergySourceConfigMapper;
  17. import com.etotem.cfc.mapper.FamilyMemberMapper;
  18. import com.etotem.cfc.mapper.WishMapper;
  19. import com.etotem.cfc.service.EnergyRuleEngine;
  20. import com.etotem.cfc.service.EnergyService;
  21. import com.etotem.cfc.service.NotificationDispatchService;
  22. import org.junit.jupiter.api.BeforeEach;
  23. import org.junit.jupiter.api.DisplayName;
  24. import org.junit.jupiter.api.Test;
  25. import org.mockito.ArgumentCaptor;
  26. import java.lang.reflect.Field;
  27. import java.lang.reflect.Method;
  28. import java.lang.reflect.Modifier;
  29. import java.text.SimpleDateFormat;
  30. import java.util.Arrays;
  31. import java.util.Calendar;
  32. import java.util.Collections;
  33. import java.util.Date;
  34. import java.util.HashMap;
  35. import java.util.List;
  36. import java.util.Map;
  37. import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
  38. import static org.junit.jupiter.api.Assertions.assertThrows;
  39. import static org.junit.jupiter.api.Assertions.assertTrue;
  40. import static org.junit.jupiter.api.Assertions.fail;
  41. import static org.mockito.ArgumentMatchers.any;
  42. import static org.mockito.ArgumentMatchers.anyInt;
  43. import static org.mockito.ArgumentMatchers.anyLong;
  44. import static org.mockito.Mockito.atLeastOnce;
  45. import static org.mockito.Mockito.atMost;
  46. import static org.mockito.Mockito.mock;
  47. import static org.mockito.Mockito.never;
  48. import static org.mockito.Mockito.times;
  49. import static org.mockito.Mockito.verify;
  50. import static org.mockito.Mockito.when;
  51. /**
  52. * 契约级单测:五维能量规则引擎实时触发写入(能力键 {@code energy.ruleEngine.apply},任务 S-cfc-304,TDD-RED 阶段)。
  53. *
  54. * <p><b>需求/设计溯源</b></p>
  55. * <ul>
  56. * <li>需求:{@code tests/user-scenarios/应用场景总览.md} 业务域 C-2——
  57. * SC-P-87(任务完成触发五维能量按规则归因增长)、SC-P-88(心愿兑换扣减五维能量余额不为负)、
  58. * SC-P-90(五维每日获取上限 DailyLimit)、SC-P-93(文章互动与活动参与触发五维能量);
  59. * 叙事 {@code tests/user-scenarios/07-five-dimension.md} 场景 ED-1(任务归因)/ED-2(心愿扣减)/
  60. * ED-4(日上限)/ED-7(文章·活动);
  61. * 用例 {@code tests/test-cases/parent.md} TC-P-87 / TC-P-88 / TC-P-90 / TC-P-93(含 -E 异常流 / -P 权限流)。</li>
  62. * <li>设计:{@code docs/superpowers/api/API_REFERENCE.md} §4.5(/api/energy/logs 流水写盘依据——
  63. * {@code sourceType}/{@code sourceId}/{@code dimensionId}/{@code amount}/{@code balanceAfter});
  64. * 模块 {@link EnergyRuleEngine}(事件→规则匹配→归因维度+数值)/ {@link EnergyBalance}(余额账本)/
  65. * {@code DimensionDailyLimit}(日上限,S-cfc-306 同链)。</li>
  66. * <li><b>职责边界</b>:本键 = <b>实时触发写入(事前/事中)</b>——事件触发时规则引擎把事件映射为
  67. * 归因维度+数值并写 {@code EnergyLog}/{@code EnergyBalance}(SC-P-87/88/90/93 的写入路径);
  68. * <b>事后校验</b>(流水对账/唯一键/归属守卫)由 {@code energy.ledger.guard}(S-cfc-225,
  69. * EnergyLedgerGuardContractTest)覆盖;<b>服务侧日上限守卫入口</b>(public guard + 配置驱动)由
  70. * {@code energy.dailyLimit.guard}(S-cfc-306,EnergyDailyLimitGuardContractTest)覆盖。
  71. * 本键只锚 apply 写路径自身:入口/可观测结果/归因生效/幂等/异常告警传播/扣减拒绝,与二者互补不重复。</li>
  72. * </ul>
  73. *
  74. * <p><b>被校验的契约行为(TDD-RED 锚点,当前实现未落地 → 红)</b></p>
  75. * <ul>
  76. * <li><b>apply 入口(能力键名)</b>:{@link EnergyRuleEngine} 应暴露 public {@code apply(...)} 实时触发入口
  77. * (事件→规则匹配→归因维度+数值→写 EnergyLog/EnergyBalance)——当前仅有 {@code evaluate(...)}(反射结构探测);</li>
  78. * <li><b>返回可观测结果(SC-P-87/90,事前·事中可感知)</b>:{@code apply} 应返回非 void 结果
  79. * (归因维度→amount、拒绝原因、日上限触顶标记「已达今日上限」),调用方(TaskController/ArticleService/
  80. * ActivityService)可感知写入结果——当前 {@code evaluate} 返回 void,日上限触顶(ED-4)、拒绝均不可观测;</li>
  81. * <li><b>规则归因生效(SC-P-87 主流程)</b>:规则声明 {@code dimensionCode=body} 时,apply 应把能量写入 body
  82. * 维度({@code EnergyLog.dimensionId=body})——当前 {@code evaluate} increase 分支把规则解析出的 dimId
  83. * 丢弃、直接 {@code awardEnergy},无 behavior/source 配置时回落默认 action(ED-1「系统按 EnergyRuleEngine
  84. * 将任务类型映射到的维度增加 amount」不成立);</li>
  85. * <li><b>文章互动归因(SC-P-93/ED-7)</b>:{@code eventType=article} 规则声明 {@code dimensionCode=mind} 时
  86. * 写 mind 维度——当前同样回落 action(行为断言);</li>
  87. * <li><b>活动参与归因(SC-P-93/ED-7 第 2 类触发源)</b>:{@code eventType=activity} 规则声明
  88. * {@code dimensionCode=wisdom} 时写 wisdom 维度——当前同样回落 action(行为断言);</li>
  89. * <li><b>同源重复触发幂等(SC-P-87 边界/ED-1)</b>:同一 {@code (memberId, sourceType=task, sourceId)}
  90. * 重复触发(重复审批/网络重试)只写一次 {@code EnergyLog}——当前 {@code evaluate} 每次直接 award,
  91. * 无写路径幂等(行为断言;schema 侧幂等唯一键由 S-cfc-225 覆盖);</li>
  92. * <li><b>规则计算异常告警传播(SC-P-87-E-4/ED-1)</b>:写入层/规则计算异常应传播给调用方(可告警、可回滚),
  93. * 不得静默吞掉——当前 {@code evaluate} 内部 {@code catch (Exception e) { log.error(...) }} 吞掉继续;</li>
  94. * <li><b>amount null/负拒绝(SC-P-87-E-4)</b>:规则 {@code amount} 缺失/负属配置异常,应拒绝并告警——
  95. * 当前 {@code calculateAmount} 对 null 返回 0 静默 {@code continue};</li>
  96. * <li><b>余额不足可感知拒绝(SC-P-88-E-1/ED-2)</b>:decrease 规则在余额不足时应向调用方暴露拒绝
  97. * (异常/结果标记「能量不足」),不得静默忽略 {@code deductEnergy} 的 -1——当前 {@code evaluate}
  98. * 忽略返回且不抛错(余额不为负本身由 {@code EnergyService.deductEnergy} 保证,本键锚调用方可感知性)。</li>
  99. * <li><b>日上限配置驱动(SC-P-90 前置/ED-4)</b>:{@link EnergyRuleEngine} 应注入
  100. * {@link DimensionDailyLimitMapper},按 {@code energy_daily_limit} 配置({@code DimensionDailyLimit})
  101. * 判定单维度日上限——当前引擎无该注入点,写路径只能落到 {@code EnergyService} 的硬编码
  102. * {@code DAILY_LIMIT_MAP}(配置变更对规则触发不生效);</li>
  103. * <li><b>单维度触顶不再累加(SC-P-90 主流程 2/ED-4)</b>:配置 {@code body dailyLimit=10}、当日累计 8、
  104. * 规则 +5(8+5&gt;10)→ 触顶,写路径不得新增 {@code EnergyLog}——当前配置不参与判定(硬编码 body=50)
  105. * → 照常写入(行为断言);</li>
  106. * <li><b>多来源共享日上限(SC-P-90-E-1/ED-4)</b>:task 来源当日已把 body 累计打到 10(触顶),
  107. * article 来源同维度再触发同样受限、不写流水——多来源共享同一日上限(行为断言);</li>
  108. * <li><b>上限 0/负不崩溃(SC-P-90-E-4/ED-4)</b>:配置 {@code dailyLimit=0} 按 0 处理(不再累加)
  109. * 且不得崩溃——当前未读取配置 → 照常写入(行为断言 + 不抛异常);</li>
  110. * </ul>
  111. *
  112. * <p><b>正常流锚点(已实现 → 绿,如实记录非 RED)</b></p>
  113. * <ul>
  114. * <li>无匹配规则的事件:{@code evaluate} 直接返回、不写任何流水;</li>
  115. * <li>归因写入的流水承载 {@code sourceType=task}/{@code sourceId=任务实例ID}(/api/energy/logs 写盘依据);</li>
  116. * <li><b>次日重置 / 跨时区以服务端日期为准(SC-P-90 主流程 3 + 异常边界)</b>:写路径的日累计查询以服务端
  117. * 「今日 00:00:00–23:59:59.999」窗口绑定 {@code energy_log.created_at}({@code between}),窗口随服务端
  118. * 日期前移 → 昨日流水不计入今日累计、客户端时钟不可绕过(wrapper 参数断言,当前已生效)。</li>
  119. * </ul>
  120. *
  121. * <p><b>权限流(TC-P-87-P/88-P/90-P/93-P)</b>:跨角色/跨家庭能量访问 403 由
  122. * {@link EnergyIsolationContractTest}(数据隔离)覆盖、日上限配置越权由
  123. * {@link EnergyConfigAdminContractTest}(admin 守卫)覆盖,本键为内部触发写入路径,权限流不适用(说明性)。</p>
  124. *
  125. * <p><b>RED 预期</b>:13 条契约缺口断言失败(红,失败原文含 {@code RED[energy.ruleEngine.apply] …})、
  126. * 3 条正常流锚点通过(绿)、1 条权限流标注(绿,说明性)。GREEN 阶段按 SC-P-87/88/90/93 落地
  127. * {@code apply}(public 入口 + 可观测结果 + 规则归因生效 + 写路径幂等 + 异常告警传播 + 扣减拒绝感知
  128. * + {@code DimensionDailyLimit} 配置驱动日上限 + 多来源共享触顶 + 0/负安全)后自动转绿。</p>
  129. *
  130. * <p><b>版本增补(v2,SC-P-90/SC-P-93 覆盖补强)</b>:v1(commit {@code 62d0240ff} 已合入主链,
  131. * 8 RED + 3 绿)覆盖 apply 入口/可观测/归因/幂等/告警/扣减拒绝,但 SC-P-90({@code DimensionDailyLimit}
  132. * 日上限)仅作为「apply 结果应可观测触顶」的附属断言出现,缺写路径端到端覆盖。v2 在隔离 worktree 增补
  133. * 5 条 RED(引擎日上限配置注入 / 单维度触顶不累加 / 多来源共享触顶 / 上限 0·负不崩溃 /
  134. * 活动参与归因)+ 1 条 GREEN 锚点(次日重置·服务端日期窗口),使 SC-P-87/88/90/93 四场景在本键均有
  135. * 写路径断言。与 {@code energy.dailyLimit.guard}(S-cfc-306,服务侧 public 守卫入口 + 配置驱动)互补:
  136. * 本键只锚「规则触发 → 写路径」的触顶行为,不重复守卫入口结构断言。</p>
  137. *
  138. * <p><b>测试范围</b>:纯 Mockito / 无 Spring 上下文 / 无 DB / 无外部服务;直接实例化
  139. * {@link EnergyRuleEngine} 注入 mock {@link EnergyRuleMapper}/{@link EnergyDimensionMapper},并把
  140. * mock 依赖注入的 {@link EnergyService} 实例作为 {@code energyService} 字段注入引擎
  141. * (复用 {@link EnergyContractTestBase#inject}/{@link EnergyContractTestBase#fiveDims}),
  142. * 反射结构探测 + 行为断言(写入捕获/异常传播/幂等计数)。</p>
  143. *
  144. * <p><b>本类与同族能量测试互补清单</b>:
  145. * {@code energy.ledger.guard}(S-cfc-225)= 事后对账/唯一键/归属守卫;
  146. * {@code energy.dailyLimit.guard}(S-cfc-306)= 服务侧 public 守卫入口 + 配置驱动;
  147. * {@code energy.fiveDim.view}/view 查看口径由 EnergyFiveDimViewContractTest 覆盖;
  148. * 本键 {@code energy.ruleEngine.apply}(S-cfc-304)= 实时触发写入(事前/事中)。</p>
  149. */
  150. class EnergyRuleEngineApplyContractTest extends EnergyContractTestBase {
  151. private static final Long MEMBER_ID = 50L;
  152. private static final Long TASK_ID = 100L;
  153. /** 日上限配置实体/Mapper(SC-P-90 前置:energy_daily_limit) */
  154. private static final String DIMENSION_DAILY_LIMIT_MAPPER = "com.etotem.cfc.mapper.DimensionDailyLimitMapper";
  155. private EnergyRuleEngine engine;
  156. private EnergyService service;
  157. private EnergyRuleMapper ruleMapper;
  158. private EnergyDimensionMapper dimensionMapper;
  159. private EnergyBehaviorConfigMapper behaviorConfigMapper;
  160. private EnergyLogMapper logMapper;
  161. private EnergyBalanceMapper balanceMapper;
  162. private FamilyMemberMapper familyMemberMapper;
  163. private EnergySourceConfigMapper sourceConfigMapper;
  164. @BeforeEach
  165. void setUp() throws Exception {
  166. engine = new EnergyRuleEngine();
  167. service = new EnergyService();
  168. ruleMapper = mock(EnergyRuleMapper.class);
  169. dimensionMapper = mock(EnergyDimensionMapper.class);
  170. behaviorConfigMapper = mock(EnergyBehaviorConfigMapper.class);
  171. logMapper = mock(EnergyLogMapper.class);
  172. balanceMapper = mock(EnergyBalanceMapper.class);
  173. familyMemberMapper = mock(FamilyMemberMapper.class);
  174. sourceConfigMapper = mock(EnergySourceConfigMapper.class);
  175. inject(engine, "energyRuleMapper", ruleMapper);
  176. inject(engine, "energyDimensionMapper", dimensionMapper);
  177. inject(engine, "energyService", service);
  178. inject(service, "energyDimensionMapper", dimensionMapper);
  179. inject(service, "energyBehaviorConfigMapper", behaviorConfigMapper);
  180. inject(service, "energyLogMapper", logMapper);
  181. inject(service, "energyBalanceMapper", balanceMapper);
  182. inject(service, "familyMemberMapper", familyMemberMapper);
  183. inject(service, "energySourceConfigMapper", sourceConfigMapper);
  184. inject(service, "wishMapper", mock(WishMapper.class));
  185. inject(service, "notificationDispatchService", mock(NotificationDispatchService.class));
  186. when(dimensionMapper.selectList(any())).thenReturn(Arrays.asList(fiveDims()));
  187. when(dimensionMapper.selectOne(any())).thenReturn(null);
  188. when(behaviorConfigMapper.selectOne(any())).thenReturn(null);
  189. when(logMapper.selectList(any())).thenReturn(Collections.emptyList());
  190. when(balanceMapper.selectOne(any())).thenReturn(null);
  191. FamilyMember member = new FamilyMember();
  192. member.setId(MEMBER_ID);
  193. member.setUserId(12L);
  194. when(familyMemberMapper.selectById(any())).thenReturn(member);
  195. initTable(EnergyDimension.class);
  196. initTable(EnergyLog.class);
  197. initTable(EnergyBalance.class);
  198. initTable(EnergyRule.class);
  199. }
  200. // ==================== RED-1/2:apply 入口 + 可观测结果(SC-P-87/90,事前·事中可感知) ====================
  201. @Test
  202. @DisplayName("RED:EnergyRuleEngine 应暴露 public apply 实时触发入口(能力键名)")
  203. void RED_apply入口_应存在public方法() {
  204. assertTrue(findPublicApply() != null,
  205. "RED[energy.ruleEngine.apply]:EnergyRuleEngine 应暴露 public apply(...) 实时触发入口"
  206. + "(事件→规则匹配→归因维度+数值→写 EnergyLog/EnergyBalance,SC-P-87 主流程);"
  207. + "当前仅有 evaluate(...),能力键 apply 未落地,调用方只能依赖无返回、吞异常的 evaluate。");
  208. }
  209. @Test
  210. @DisplayName("RED:apply 应返回可观测结果(归因/拒绝/日上限触顶可感知,SC-P-87/90)")
  211. void RED_apply结果_非void可观测() {
  212. Method apply = findPublicApply();
  213. if (apply == null) {
  214. fail("RED[energy.ruleEngine.apply]:apply 入口缺失 → 调用方必然无法拿到归因/拒绝/触顶结果"
  215. + "(SC-P-87/ED-1 归因可核对、SC-P-90/ED-4『已达今日上限』触顶展示、SC-P-88『能量不足』拒绝文案),"
  216. + "当前 evaluate 返回 void 且吞异常,触发侧(TaskController/ArticleService/ActivityService)"
  217. + "无法感知写入结果。");
  218. }
  219. assertTrue(apply.getReturnType() != void.class && apply.getReturnType() != Void.class,
  220. "RED[energy.ruleEngine.apply]:apply 应返回非 void 结果(Map<dimensionCode,amount> 或带"
  221. + "capped/rejected 标记的结果对象),使日上限触顶(ED-4)、余额不足拒绝(ED-2)可被调用方感知;"
  222. + "当前 evaluate 返回 void,触顶/拒绝均不可观测。");
  223. }
  224. // ==================== RED-3/4:规则归因生效(SC-P-87/93,ED-1/ED-7 主流程) ====================
  225. @Test
  226. @DisplayName("RED:任务事件规则声明归因维度 body → EnergyLog 应写 body 维度(SC-P-87)")
  227. void RED_归因_任务规则写body维度() {
  228. EnergyRule rule = rule(1L, "task", "increase", "body", 10, 1);
  229. when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
  230. when(dimensionMapper.selectOne(any())).thenReturn(dim(5L, "body", "身体", "土"));
  231. engine.evaluate("task", TASK_ID, MEMBER_ID, new HashMap<>());
  232. List<EnergyLog> written = captureInsertedLogs();
  233. boolean wroteBody = written.stream().anyMatch(l ->
  234. l.getDimensionId() != null && l.getDimensionId().longValue() == 5L);
  235. assertTrue(wroteBody,
  236. "RED[energy.ruleEngine.apply]:任务事件规则声明归因维度 body(id=5),按规则应把能量写入 body 维度"
  237. + "(ED-1 主流程 2『系统按 EnergyRuleEngine 将任务类型映射到的维度增加 amount』+ 主流程 3 写"
  238. + " EnergyLog.dimensionId)。当前 evaluate 的 increase 分支把规则解析出的 dimId 丢弃、直接"
  239. + " awardEnergy → 无 behavior/source 配置时回落默认 action(id=3)维度,实际写入 dimensionId="
  240. + written.get(0).getDimensionId() + ",规则归因维度未生效(SC-P-87 缺口)。");
  241. }
  242. @Test
  243. @DisplayName("RED:文章互动事件规则声明归因维度 mind → EnergyLog 应写 mind 维度(SC-P-93/ED-7)")
  244. void RED_归因_文章互动规则写mind维度() {
  245. EnergyRule rule = rule(2L, "article", "increase", "mind", 5, 1);
  246. when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
  247. when(dimensionMapper.selectOne(any())).thenReturn(dim(4L, "mind", "心智", "火"));
  248. engine.evaluate("article", 200L, MEMBER_ID, new HashMap<>());
  249. List<EnergyLog> written = captureInsertedLogs();
  250. boolean wroteMind = written.stream().anyMatch(l ->
  251. l.getDimensionId() != null && l.getDimensionId().longValue() == 4L);
  252. assertTrue(wroteMind,
  253. "RED[energy.ruleEngine.apply]:文章互动事件(SC-P-93/ED-7 主流程 1『发布/评论文章…触发 EnergyRuleEngine"
  254. + " 对应维度 +amount』)规则声明归因维度 mind(id=4),应写入 mind 维度;当前回落默认 action"
  255. + "(id=3)维度,实际写入 dimensionId=" + written.get(0).getDimensionId()
  256. + ",文章互动归因维度未生效(SC-P-93 缺口)。");
  257. }
  258. @Test
  259. @DisplayName("RED:活动参与事件规则声明归因维度 wisdom → EnergyLog 应写 wisdom 维度(SC-P-93/ED-7)")
  260. void RED_归因_活动参与规则写wisdom维度() {
  261. // SC-P-93 第 2 类触发源:报名/参与平台活动 → 按规则加对应维度能量
  262. EnergyRule rule = rule(9L, "activity", "increase", "wisdom", 3, 1);
  263. when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
  264. when(dimensionMapper.selectOne(any())).thenReturn(dim(1L, "wisdom", "智慧", "金"));
  265. engine.evaluate("activity", 400L, MEMBER_ID, new HashMap<>());
  266. List<EnergyLog> written = captureInsertedLogs();
  267. boolean wroteWisdom = written.stream().anyMatch(l ->
  268. l.getDimensionId() != null && l.getDimensionId().longValue() == 1L);
  269. assertTrue(wroteWisdom,
  270. "RED[energy.ruleEngine.apply]:活动参与事件(SC-P-93/ED-7 主流程 1『…报名参与活动 → 触发"
  271. + " EnergyRuleEngine 对应维度 +amount』)规则声明归因维度 wisdom(id=1),应写入 wisdom 维度;"
  272. + "当前回落默认 action(id=3)维度,实际写入 dimensionId=" + written.get(0).getDimensionId()
  273. + ",活动参与归因维度未生效(SC-P-93 缺口)。");
  274. }
  275. // ==================== RED-5:同源重复触发幂等(SC-P-87 边界/ED-1) ====================
  276. @Test
  277. @DisplayName("RED:同 member+task+sourceId 重复触发只写一次 EnergyLog(重复审批幂等)")
  278. void RED_幂等_同源重复触发只写一次() {
  279. EnergyRule rule = rule(3L, "task", "increase", "body", 1, 1);
  280. when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
  281. when(dimensionMapper.selectOne(any())).thenReturn(dim(5L, "body", "身体", "土"));
  282. engine.evaluate("task", TASK_ID, MEMBER_ID, new HashMap<>());
  283. engine.evaluate("task", TASK_ID, MEMBER_ID, new HashMap<>());
  284. verify(logMapper, times(1)).insert(any(EnergyLog.class));
  285. }
  286. // ==================== RED-6/7:规则计算异常告警(SC-P-87-E-4/ED-1 边界) ====================
  287. @Test
  288. @DisplayName("RED:写入层异常应传播给调用方(可告警),不得静默吞掉")
  289. void RED_告警_写入异常应传播() throws Exception {
  290. // 注入一个写入即抛的 mock EnergyService:契约要求 apply 把异常传播给调用方(TaskController 可告警/回滚)
  291. EnergyService throwing = mock(EnergyService.class);
  292. when(throwing.awardEnergy(anyLong(), any(), any(), anyInt(), any(), any()))
  293. .thenThrow(new RuntimeException("写入层故障: energy_balance update failed"));
  294. EnergyRuleEngine engineWithThrowing = new EnergyRuleEngine();
  295. inject(engineWithThrowing, "energyRuleMapper", ruleMapper);
  296. inject(engineWithThrowing, "energyDimensionMapper", dimensionMapper);
  297. inject(engineWithThrowing, "energyService", throwing);
  298. EnergyRule rule = rule(4L, "task", "increase", "body", 10, 1);
  299. when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
  300. when(dimensionMapper.selectOne(any())).thenReturn(dim(5L, "body", "身体", "土"));
  301. assertThrows(RuntimeException.class,
  302. () -> engineWithThrowing.evaluate("task", TASK_ID, MEMBER_ID, new HashMap<>()),
  303. "RED[energy.ruleEngine.apply]:写入层异常应传播给调用方(SC-P-87-E-4『规则计算异常告警、不写脏流水』"
  304. + "——调用方可感知失败并告警/回滚)。当前 evaluate 内部 catch(Exception) 仅 log.error 吞掉异常,"
  305. + "调用方(TaskController)无法得知写入失败,告警链路断点。");
  306. }
  307. @Test
  308. @DisplayName("RED:规则 amount 缺失/负值应拒绝并告警,不得静默跳过")
  309. void RED_告警_amount缺失负值应拒绝() {
  310. // 规则 amount 缺失(配置异常):合约 = 拒绝并告警;当前 calculateAmount 对 null 返回 0 → 静默 continue
  311. EnergyRule rule = rule(5L, "task", "increase", "body", null, 1);
  312. when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
  313. assertThrows(IllegalArgumentException.class,
  314. () -> engine.evaluate("task", TASK_ID, MEMBER_ID, new HashMap<>()),
  315. "RED[energy.ruleEngine.apply]:规则 amount 缺失/负值属配置异常,契约要求拒绝并告警"
  316. + "(SC-P-87-E-4:规则计算异常→拒绝执行并告警,不写脏流水);当前 calculateAmount 对 null"
  317. + " 返回 0 后 evaluate 静默 continue,无任何拒绝/告警信号。");
  318. verify(logMapper, never()).insert(any(EnergyLog.class));
  319. }
  320. // ==================== RED-8:余额不足可感知拒绝(SC-P-88-E-1/ED-2) ====================
  321. @Test
  322. @DisplayName("RED:decrease 规则余额不足应向调用方暴露拒绝(不得静默忽略 deductEnergy 的 -1)")
  323. void RED_扣减_余额不足应可感知() {
  324. // 心愿兑换扣减场景(ED-2/SC-P-88):B 该维度 balance=0,decrease 规则 amount=10 → 余额不足
  325. EnergyRule rule = rule(6L, "wish", "decrease", "body", 10, 1);
  326. when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
  327. when(dimensionMapper.selectOne(any())).thenReturn(dim(5L, "body", "身体", "土"));
  328. assertThrows(IllegalStateException.class,
  329. () -> engine.evaluate("wish", 300L, MEMBER_ID, new HashMap<>()),
  330. "RED[energy.ruleEngine.apply]:心愿兑换扣减(SC-P-88-E-1『余额不足明确返回能量不足、心愿保持待审批、"
  331. + "不出现负余额』)余额不足时,apply 应向调用方暴露拒绝信号(异常/结果标记),不得静默忽略"
  332. + " deductEnergy 的 -1 返回值;当前 evaluate 忽略扣减返回且不抛错,兑换侧无法感知『能量不足』。");
  333. }
  334. // ==================== RED-9~12:日上限 DailyLimit 写路径(SC-P-90/ED-4) ====================
  335. @Test
  336. @DisplayName("RED:EnergyRuleEngine 应注入 DimensionDailyLimitMapper(日上限配置驱动,SC-P-90 前置)")
  337. void RED_日上限_引擎配置驱动注入() {
  338. boolean hasMapper = false;
  339. for (Field f : EnergyRuleEngine.class.getDeclaredFields()) {
  340. if (DIMENSION_DAILY_LIMIT_MAPPER.equals(f.getType().getName())) {
  341. hasMapper = true;
  342. break;
  343. }
  344. }
  345. assertTrue(hasMapper,
  346. "RED[energy.ruleEngine.apply]:EnergyRuleEngine 应注入 DimensionDailyLimitMapper,按"
  347. + " energy_daily_limit 配置(DimensionDailyLimit.dailyLimit)判定实时触发写入的单维度日上限"
  348. + "(SC-P-90 前置『DimensionDailyLimit 已配置某维度 dailyLimit=N』/ED-4)。当前引擎无该注入点,"
  349. + "写路径只能落到 EnergyService 的硬编码 DAILY_LIMIT_MAP(body=50 等)→ 运营改配置对规则触发不生效。");
  350. }
  351. @Test
  352. @DisplayName("RED:单维度当日累计触顶后不再累加(SC-P-90 主流程 2)")
  353. void RED_日上限_触顶不再累加() {
  354. bindDailyLimit("body", 10);
  355. // 当日 body 已累计 8(来自 checkin 来源),规则再 +5 → 8+5 > 10 触顶
  356. when(logMapper.selectList(any())).thenReturn(Collections.singletonList(
  357. energyLog(1L, MEMBER_ID, 5L, 8, 8, "checkin", 900L)));
  358. EnergyRule rule = rule(10L, "task", "increase", "body", 5, 1);
  359. when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
  360. when(dimensionMapper.selectOne(any())).thenReturn(dim(5L, "body", "身体", "土"));
  361. engine.evaluate("task", TASK_ID, MEMBER_ID, new HashMap<>());
  362. List<EnergyLog> written = captureInsertedLogsOrEmpty();
  363. String actual = written.isEmpty() ? "0 条" : written.size() + " 条(dimensionId="
  364. + written.get(0).getDimensionId() + ",amount=" + written.get(0).getAmount() + ")";
  365. assertTrue(written.isEmpty(),
  366. "RED[energy.ruleEngine.apply]:配置 body dailyLimit=10、当日已累计 8(checkin 来源),规则再 +5"
  367. + "(8+5>10)→ 触顶,写路径不得新增 EnergyLog(SC-P-90 主流程 2『累计达 dailyLimit 后新增触发"
  368. + "不再累加』/ED-4)。当前引擎未读取 DimensionDailyLimit 配置,仅落到硬编码 body=50 → 本次照常写入 "
  369. + actual + "。");
  370. }
  371. @Test
  372. @DisplayName("RED:多来源共享同一日上限 — task 触顶后 article 同维度同样受限(SC-P-90-E-1)")
  373. void RED_日上限_多来源共享触顶() {
  374. bindDailyLimit("body", 10);
  375. // 当日 body 已累计 10(task 来源已触顶),article 来源再触发 +5 → 多来源共享同一日上限 → 不得累加
  376. when(logMapper.selectList(any())).thenReturn(Collections.singletonList(
  377. energyLog(2L, MEMBER_ID, 5L, 10, 10, "task", TASK_ID)));
  378. EnergyRule rule = rule(11L, "article", "increase", "body", 5, 1);
  379. when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
  380. when(dimensionMapper.selectOne(any())).thenReturn(dim(5L, "body", "身体", "土"));
  381. engine.evaluate("article", 200L, MEMBER_ID, new HashMap<>());
  382. List<EnergyLog> written = captureInsertedLogsOrEmpty();
  383. assertTrue(written.isEmpty(),
  384. "RED[energy.ruleEngine.apply]:多来源(任务+打卡+活动)共享同一日上限——当日 body 已由 task 来源累计到"
  385. + " 10(配置 dailyLimit=10)触顶,article 来源同维度再触发 +5 应同样受限、不写流水"
  386. + "(SC-P-90-E-1『任一来源达成后其余来源同维度均受限』/ED-4)。当前配置不参与判定 → 本次照常写入 "
  387. + written.size() + " 条。");
  388. }
  389. @Test
  390. @DisplayName("RED:上限 0/负不崩溃 — 配置 dailyLimit=0 按 0 处理不累加(SC-P-90-E-4)")
  391. void RED_日上限_零负不崩溃() {
  392. bindDailyLimit("body", 0);
  393. EnergyRule rule = rule(12L, "task", "increase", "body", 10, 1);
  394. when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
  395. when(dimensionMapper.selectOne(any())).thenReturn(dim(5L, "body", "身体", "土"));
  396. assertDoesNotThrow(() -> engine.evaluate("task", TASK_ID, MEMBER_ID, new HashMap<>()),
  397. "SC-P-90-E-4:日上限配置为 0/负不得崩溃(NPE/除零/负数异常),应按 0 处理。");
  398. List<EnergyLog> written = captureInsertedLogsOrEmpty();
  399. assertTrue(written.isEmpty(),
  400. "RED[energy.ruleEngine.apply]:配置 body dailyLimit=0(SC-P-90-E-4『日上限配置为 0 或负数:拒绝配置或"
  401. + "按 0 处理,不得崩溃』)→ 按 0 处理、不再累加,写路径不得新增 EnergyLog。当前引擎未读取配置"
  402. + " → 本次照常写入 " + written.size() + " 条。");
  403. }
  404. // ==================== 正常流锚点(已实现 → 绿,如实记录非 RED) ====================
  405. @Test
  406. @DisplayName("GREEN anchor:次日重置/跨时区 — 日累计查询绑定服务端今日窗口(SC-P-90 主流程 3)")
  407. void GREEN_日上限_次日重置服务端窗口() {
  408. // SC-P-90 主流程 3 + 异常边界:跨日 00:00 累计清零,时钟/跨时区以服务端日期为准(不接收客户端时间入参)。
  409. // 写路径的日累计查询必须把 energy_log.created_at 绑定到服务端「今日 00:00:00–23:59:59.999」窗口,
  410. // 窗口随服务端日期前移 → 昨日流水不计入今日累计(当前已生效,非 RED)。
  411. EnergyRule rule = rule(13L, "task", "increase", "body", 1, 1);
  412. when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
  413. when(dimensionMapper.selectOne(any())).thenReturn(dim(5L, "body", "身体", "土"));
  414. engine.evaluate("task", TASK_ID, MEMBER_ID, new HashMap<>());
  415. Date todayStart = serverTodayStart();
  416. Date todayEnd = serverTodayEnd();
  417. SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
  418. boolean windowBound = false;
  419. for (Wrapper w : captureLogQueryWrappers()) {
  420. if (!(w instanceof AbstractWrapper)) continue;
  421. AbstractWrapper<?, ?, ?> wrapper = (AbstractWrapper<?, ?, ?>) w;
  422. // MP 的参数值在 SQL 片段求值时写入 paramNameValuePairs → 先触发 getSqlSegment()
  423. String sqlSegment = wrapper.getSqlSegment();
  424. if (sqlSegment == null || !sqlSegment.contains("created_at")) continue;
  425. boolean hasStart = false;
  426. boolean hasEnd = false;
  427. for (Object v : wrapper.getParamNameValuePairs().values()) {
  428. if (!(v instanceof Date)) continue;
  429. if (((Date) v).getTime() == todayStart.getTime()) hasStart = true;
  430. if (((Date) v).getTime() == todayEnd.getTime()) hasEnd = true;
  431. }
  432. if (hasStart && hasEnd) {
  433. windowBound = true;
  434. break;
  435. }
  436. }
  437. assertTrue(windowBound,
  438. "GREEN anchor[energy.ruleEngine.apply]:日上限累计查询应把 created_at 绑定到服务端今日窗口 ["
  439. + fmt.format(todayStart) + ", " + fmt.format(todayEnd) + "](SC-P-90 主流程 3 次日重置 /"
  440. + " 异常边界『以服务端日期为准』)。未捕获到带今日窗口参数的查询 → 跨日累计不会归零。");
  441. }
  442. @Test
  443. @DisplayName("GREEN anchor:无匹配规则的事件不写任何流水")
  444. void GREEN_无规则不写流水() {
  445. when(ruleMapper.selectList(any())).thenReturn(Collections.emptyList());
  446. engine.evaluate("task", TASK_ID, MEMBER_ID, new HashMap<>());
  447. verify(logMapper, never()).insert(any(EnergyLog.class));
  448. }
  449. @Test
  450. @DisplayName("GREEN anchor:归因写入的流水承载 sourceType=task/sourceId(/api/energy/logs 写盘依据)")
  451. void GREEN_流水承载sourceType与sourceId() {
  452. EnergyRule rule = rule(7L, "task", "increase", "body", 1, 1);
  453. when(ruleMapper.selectList(any())).thenReturn(Collections.singletonList(rule));
  454. when(dimensionMapper.selectOne(any())).thenReturn(dim(5L, "body", "身体", "土"));
  455. engine.evaluate("task", TASK_ID, MEMBER_ID, new HashMap<>());
  456. List<EnergyLog> written = captureInsertedLogs();
  457. assertTrue(written.stream().anyMatch(l -> "task".equals(l.getSourceType())
  458. && Long.valueOf(TASK_ID).equals(l.getSourceId())),
  459. "GREEN anchor:归因写入的 EnergyLog 应承载 sourceType=task、sourceId=任务实例ID"
  460. + "(ED-1 主流程 3 + API_REFERENCE §4.5 /api/energy/logs 写盘依据,当前已生效)。");
  461. }
  462. // ==================== 权限流(TC-P-87-P/88-P/90-P/93-P,说明性) ====================
  463. @Test
  464. @DisplayName("权限流:跨角色/跨家庭能量访问 403 由隔离/守卫测试覆盖,本键不适用")
  465. void 权限流_不适用() {
  466. // 契约 AC 为「事件→规则→写入」内部触发链路,无用户权限维度。
  467. // TC-P-87-P/88-P/93-P(家长 A 查/改 F9 成员能量 403、孩子 B 调 grant/deduct 被拒)
  468. // 由 EnergyIsolationContractTest(数据隔离)覆盖;TC-P-90-P(越权改 F9 DailyLimit 403)
  469. // 由 EnergyConfigAdminContractTest(admin 守卫)覆盖。
  470. assertTrue(true, "权限流不适用:energy.ruleEngine.apply 为内部实时触发写入路径,访问控制在 Controller 层。");
  471. }
  472. // ==================== 辅助 ====================
  473. /** 反射寻找 public apply(...) 入口(当前不存在 → null) */
  474. private static Method findPublicApply() {
  475. for (Method m : EnergyRuleEngine.class.getDeclaredMethods()) {
  476. if ("apply".equals(m.getName()) && Modifier.isPublic(m.getModifiers())) {
  477. return m;
  478. }
  479. }
  480. return null;
  481. }
  482. /** 捕获并返回本次发生的全部 EnergyLog.insert 参数 */
  483. private List<EnergyLog> captureInsertedLogs() {
  484. ArgumentCaptor<EnergyLog> captor = ArgumentCaptor.forClass(EnergyLog.class);
  485. verify(logMapper, atLeastOnce()).insert(captor.capture());
  486. return captor.getAllValues();
  487. }
  488. /** 捕获 insert 参数(允许 0 条,用于「不应写入」断言) */
  489. private List<EnergyLog> captureInsertedLogsOrEmpty() {
  490. ArgumentCaptor<EnergyLog> captor = ArgumentCaptor.forClass(EnergyLog.class);
  491. verify(logMapper, atMost(5)).insert(captor.capture());
  492. return captor.getAllValues();
  493. }
  494. /** 捕获日累计/流水查询的 wrapper(用于校验服务端今日窗口绑定) */
  495. @SuppressWarnings("unchecked")
  496. private List<Wrapper> captureLogQueryWrappers() {
  497. ArgumentCaptor<Wrapper> captor = ArgumentCaptor.forClass(Wrapper.class);
  498. verify(logMapper, atLeastOnce()).selectList(captor.capture());
  499. return captor.getAllValues();
  500. }
  501. /**
  502. * 绑定引擎侧日上限配置(SC-P-90 前置:DimensionDailyLimit 配 dailyLimit=N)。
  503. * 当前 {@link EnergyRuleEngine} 缺 {@code dimensionDailyLimitMapper} 注入点 → 直接 RED 失败并给出契约原文。
  504. */
  505. private void bindDailyLimit(String dimensionCode, int dailyLimit) {
  506. DimensionDailyLimitMapper dailyLimitMapper = mock(DimensionDailyLimitMapper.class);
  507. try {
  508. inject(engine, "dimensionDailyLimitMapper", dailyLimitMapper);
  509. } catch (NoSuchFieldException e) {
  510. fail("RED[energy.ruleEngine.apply] precondition:EnergyRuleEngine 缺 dimensionDailyLimitMapper 注入点"
  511. + "(NoSuchFieldException),无法按 energy_daily_limit 配置判定单维度日上限"
  512. + "(SC-P-90 前置『DimensionDailyLimit 已配置某维度 dailyLimit=" + dailyLimit + "』)。");
  513. return;
  514. } catch (Exception e) {
  515. fail("RED[energy.ruleEngine.apply] precondition:注入 dimensionDailyLimitMapper 失败:"
  516. + e.getClass().getSimpleName() + " " + e.getMessage());
  517. return;
  518. }
  519. initTable(DimensionDailyLimit.class);
  520. DimensionDailyLimit config = new DimensionDailyLimit();
  521. config.setId(1L);
  522. config.setDimensionCode(dimensionCode);
  523. config.setDailyLimit(dailyLimit);
  524. config.setCreatedAt(new Date());
  525. config.setUpdatedAt(new Date());
  526. when(dailyLimitMapper.selectList(any())).thenReturn(Collections.singletonList(config));
  527. when(dailyLimitMapper.selectOne(any())).thenReturn(config);
  528. }
  529. /** 服务端今日 00:00:00.000(与业务侧 getTodayStart 同口径:JVM 服务端时钟) */
  530. private static Date serverTodayStart() {
  531. Calendar cal = Calendar.getInstance();
  532. cal.set(Calendar.HOUR_OF_DAY, 0);
  533. cal.set(Calendar.MINUTE, 0);
  534. cal.set(Calendar.SECOND, 0);
  535. cal.set(Calendar.MILLISECOND, 0);
  536. return cal.getTime();
  537. }
  538. /** 服务端今日 23:59:59.999(与业务侧 getTodayEnd 同口径) */
  539. private static Date serverTodayEnd() {
  540. Calendar cal = Calendar.getInstance();
  541. cal.set(Calendar.HOUR_OF_DAY, 23);
  542. cal.set(Calendar.MINUTE, 59);
  543. cal.set(Calendar.SECOND, 59);
  544. cal.set(Calendar.MILLISECOND, 999);
  545. return cal.getTime();
  546. }
  547. /** 规则构造(status=1 active,conditions 空 → 无条件匹配) */
  548. private static EnergyRule rule(Long id, String eventType, String action, String dimCode,
  549. Integer amount, int priority) {
  550. EnergyRule r = new EnergyRule();
  551. r.setId(id);
  552. r.setRuleCode("R" + id);
  553. r.setRuleName("规则" + id);
  554. r.setEventType(eventType);
  555. r.setAction(action);
  556. r.setDimensionCode(dimCode);
  557. r.setAmount(amount);
  558. r.setPriority(priority);
  559. r.setStatus(1);
  560. r.setDescription(eventType + "-" + dimCode + "归因");
  561. return r;
  562. }
  563. }