refactor(slim-r3): 删除零引用死模块——keywordshare/debug/PublicWorkbenchClientVersion 三线 40 件

Project-Slimming 第三轮收尾执行(用户拍板「零引用的也都要删除」):
定谳依据=6.4 天生产访问日志零流量(970 万行单遍对撞,26 UNIQUE 前缀防撞车)
+四树代码零引用(后端类名/包名/字符串、admin、用户端、app_client 全扫)
+V163 建菜单→V165 撤菜单的历史链(功能入口 10 月底已下线,Controller 成孤儿)。

删除(40 件):
- modules/keywordshare 整模块 31 类+4 mapper XML+KeywordShareServiceTest
  (后管 V165 已撤菜单、app_client 同步链 kw_share_api 亦无调用方;
  biz_keyword_share 等表按「已应用迁移不可回改」保留在库)
- modules/debug 2 支控制器(/debug/request-info、/debug/task-recovery/*)
- workbenchclient/controller/PublicWorkbenchClientVersionController
  (/api/workbench-client/version/latest:app_client 实际走 /api/version/latest,
  admin 侧仅文案引用,无任何真实调用方)
- config/KeywordShareSyncProperties(唯一消费方 KeywordShareService 同批删)

同步编辑:
- AdminApiGuardFilter:摘 DEBUG_PREFIX 前缀(常量/javadoc/审计日志块/requiresCredential/
  guardedPrefixes 五处);ApiGuardCoverageAuditor:METHOD_GUARDED_PATHS 摘 /api/keyword-share
- PropertiesConfig 摘 KeywordShareSyncProperties.class;application.yml 与
  application-local.example.yml 摘 keyword-share-sync 段与两个 env
- 台账两处扣减:XML_SELECT_TOTAL 114→103(11 select)、XML_STATEMENT_TOTAL 164→147
  (11 select+4 insert+1 delete);MigratedSqlEquivalenceTest.NOT_MIGRATED 摘 12 条点名
  (tsv 基准账本零 KeywordShare 行,LEDGER_ROWS/LEDGER_SELECTS 不动)
- PendingPhase5ReadPathTest 摘 P1-B2(RAND 断言随 XML 删);ApiGuardCoverageAuditorTest
  前缀总数 25→24;AdminApiGuardFilterTest 摘 4 支 /debug 用例与 2 条边界 URI
- admin:workbench-client-api 死常量、页面头注释与 page-hint、operation-guides 指南文案
  摘被删端点字样;align-workbench-client.test 摘 3 条对应断言

零行为影响:全部删除件在 6.4 天窗口内零流量;守卫过滤器行为对现存前缀不变
(/api/admin、用户态、自助清单原样)。
This commit is contained in:
2026-11-16 12:18:05 +08:00
parent c9ecae6e6d
commit a5e390750b
55 changed files with 23 additions and 3070 deletions
@@ -94,7 +94,9 @@ class MigratedSqlEquivalenceTest {
// 113 → 114:2026-11-15 商品上架配额计数(b9b66bcb)在 JdProductMapper 新写 1 条只读 select
//(countByUserIds,按 owner uid 集计 biz_jd_product 行数),逐条点名进 NOT_MIGRATED。
// 该笔当时只点编译没跑整量、两处账本都漏记,2026-11-15 发版前整量抓到补记。
private static final int XML_SELECT_TOTAL = 114;
// 114 → 103:keywordshare 模块整体下线(Project-Slimming 第三轮:6.4 天访问日志零流量、
// 四树零引用、V165 已撤菜单),随删 11 条 select 与下方 NOT_MIGRATED 的 12 条点名。
private static final int XML_SELECT_TOTAL = 103;
/**
* 不是「从注解搬过来」的语句:注解时代没有原文可对撞,等价性这支只能跳过它们。
@@ -112,21 +114,6 @@ class MigratedSqlEquivalenceTest {
"UserSecretUsageMapper#addTokens",
// 失败任务重试:INSERT ... SELECT 复制采集明细行,非注解迁移件。
"CollectDataItemMapper#copyItemsForRetry",
// keywordshare 模块(五国关键词共享网页化,2026-10-23)新写 11 条 select。
"KeywordShareMapper#countHit",
"KeywordShareMapper#selectRows",
"KeywordShareMapper#selectRandomUnused",
"KeywordShareMapper#countDupKeywords",
"KeywordShareMapper#selectFilterCountries",
"KeywordShareMapper#selectFilterTreeRows",
"KeywordShareMapper#selectCountryCounts",
"KeywordShareMapper#selectCategoryCounts",
"KeywordShareMapper#selectSubCategoryCounts",
"KeywordShareMapper#selectCategoryL3Counts",
"KeywordShareMapper#selectExistingKeywords",
// 工作台客户端全量同步新写的词本体 UPSERT:注解时代没有原文可对撞,按新写语句点名留痕。
// 它是 insert 不是 select,故 XML_SELECT_TOTAL 不随之变。
"KeywordShareMapper#upsertBatchFromSync",
// brandgating 模块(品牌Gating库并入管理后台,2026-10-23)新写 8 条 select。
"BrandGatingMapper#countByFilter",
"BrandGatingMapper#selectRows",
@@ -128,7 +128,10 @@ class SqlLayeringConventionTest {
//(countByUserIds,按 owner uid 集计 biz_jd_product 行数,JdPublishQuotaService 配额原语),
// 全部新写,非迁移语句。该笔当时只点编译没跑整量、两处账本都漏记,2026-11-15 发版前
// 整量抓到补记(同轮 MigratedSqlEquivalenceTest.XML_SELECT_TOTAL 113 → 114)。
private static final int XML_STATEMENT_TOTAL = 164;
// 164 → 147:keywordshare 模块整体下线(Project-Slimming 第三轮:6.4 天访问日志零流量、
// 四树零引用、V165 已撤菜单),4 份 XML 17 条语句(11 select + 4 insert + 1 delete)随删;
// 同轮 MigratedSqlEquivalenceTest.XML_SELECT_TOTAL 114 → 103、NOT_MIGRATED 摘掉 12 条点名。
private static final int XML_STATEMENT_TOTAL = 147;
/**
* wrapper 里夹带函数级 SQL 的现状("这不是简单单表"的证据),文件名 → 条数:
@@ -22,7 +22,7 @@ import static org.mockito.Mockito.when;
* 兜底鉴权过滤器单测:非受保护路径放行、OPTIONS/豁免前缀放行、
* 匿名拒绝返回与全局一致的 401 体、紧急开关可整体关闭。
*
* <p>/debug/** 于 2026-09-11 纳入保护范围,对应用例见本类后半部分。
* <p>/debug/** 用例随 debug 控制器整体下线一并移除(Project-Slimming 第三轮,2026-11-16)。
*/
class AdminApiGuardFilterTest {
@@ -178,84 +178,13 @@ class AdminApiGuardFilterTest {
assertThat(chain.getRequest()).isNotNull();
}
// ---- /debug/** 纳入保护(2026-09-11)----
// 背景:两个 debug 控制器都没有方法级鉴权,而主机A 18080 公网直连、主机B nginx location /
// 全量反代 Java,导致匿名即可调通(其中 run-stale-finalize 是强制收尾指定 task 的写操作)。
@Test
void anonymousDebugWriteEndpointRejected() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.requireUserOrInternal(any()))
.thenThrow(new BusinessException(401, "未登录"));
AdminApiGuardFilter filter = newFilter(authSupport, true, "");
MockHttpServletRequest request =
new MockHttpServletRequest("POST", "/debug/task-recovery/run-stale-finalize");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
JsonNode body = objectMapper.readTree(response.getContentAsString());
assertThat(body.path("success").asBoolean()).isFalse();
assertThat(body.path("code").asInt()).isEqualTo(401);
assertThat(chain.getRequest()).isNull();
}
@Test
void anonymousDebugRequestInfoRejected() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.requireUserOrInternal(any()))
.thenThrow(new BusinessException(401, "未登录"));
AdminApiGuardFilter filter = newFilter(authSupport, true, "");
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/debug/request-info");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
assertThat(chain.getRequest()).isNull();
assertThat(response.getContentAsString()).contains("401");
}
@Test
void debugEndpointStillReachableWithInternalToken() throws Exception {
// 应急调用方(run-stale-finalize 是文档指定的线上排障工具)带 X-Internal-Token 仍可直达
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.isTrustedInternalToken(any())).thenReturn(true);
AdminApiGuardFilter filter = newFilter(authSupport, true, "");
MockHttpServletRequest request =
new MockHttpServletRequest("POST", "/debug/task-recovery/run-stale-finalize");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
verify(authSupport, never()).requireUserOrInternal(any());
assertThat(chain.getRequest()).isNotNull();
assertThat(response.getContentAsString()).isEmpty();
}
@Test
void debugBarePrefixItselfIsGuarded() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.requireUserOrInternal(any()))
.thenThrow(new BusinessException(401, "未登录"));
AdminApiGuardFilter filter = newFilter(authSupport, true, "");
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/debug");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
assertThat(chain.getRequest()).isNull();
}
@Test
void similarLookingPathsAreNotSweptIn() throws Exception {
// 前缀边界:只按整段匹配,/debugging、/debug-tools、/api/adminx 都不应被误纳入
// 前缀边界:只按整段匹配,/api/adminx 不应被误纳入(/debugging、/debug-tools 两条
// 随 /debug 前缀下线一并移除——它们守护的前缀已不存在)
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
AdminApiGuardFilter filter = newFilter(authSupport, true, "");
for (String uri : new String[] {"/debugging", "/debug-tools/list", "/api/adminx"}) {
for (String uri : new String[] {"/api/adminx"}) {
MockHttpServletRequest request = new MockHttpServletRequest("GET", uri);
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
@@ -64,14 +64,14 @@ class ApiGuardCoverageAuditorTest {
void guardedPrefixesCarriesEveryGuardedList() {
List<String> guarded = AdminApiGuardFilter.guardedPrefixes();
assertTrue(guarded.contains("/api/admin"), "admin 前缀没进自检可见名单");
assertTrue(guarded.contains("/debug"), "debug 前缀没进自检可见名单");
// 这两组条数是实测基线(2026-10-08:用户态 15 条、自助 6 条)。
// 只钉"contains 某条"的话,从数组里删掉一整段都可能不红,所以钉总数。
// 2026-10-24 自助 6 → 7:cost-guard 的 status/resume 两个端点 uid 只从 JWT 取,
// 匿名既读不到状态也不该能解除暂停闸,所以进无条件名单而不是登记成「方法内自校验」。
// 2026-10-29 用户态 15 → 16:采集路由读取口 /api/collect-routing 新建即入名单。
assertEquals(24, count(guarded, "/api/"), () -> "以 /api/ 开头的守卫前缀数变了(基线 24 = admin 1 + 用户态 16 + 自助 7):" + guarded);
assertEquals(25, guarded.size(), "守卫前缀总数变了(24 条 /api/ + /debug):" + guarded);
// 2026-11-16 /debug 前缀随 debug 控制器整体下线(Project-Slimming 第三轮)后,总名单 = 24 条 /api/。
assertEquals(24, guarded.size(), "守卫前缀总数变了(24 条 /api/):" + guarded);
assertTrue(guarded.contains("/api/publish"), "2026-10-07 补的上架前缀不能退回名单外");
assertTrue(guarded.contains("/api/tasks"), "心跳/打断前缀不能退回名单外");
assertTrue(guarded.contains("/api/internal"), "内部端点前缀不能退回名单外");
@@ -1,690 +0,0 @@
package com.nanri.aiimage.modules.keywordshare.service;
import com.nanri.aiimage.config.KeywordShareSyncProperties;
import com.nanri.aiimage.modules.keywordshare.mapper.KeywordAddLogMapper;
import com.nanri.aiimage.modules.keywordshare.mapper.KeywordDeleteLogMapper;
import com.nanri.aiimage.modules.keywordshare.mapper.KeywordShareMapper;
import com.nanri.aiimage.modules.keywordshare.mapper.KeywordUsageMapper;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareFilterQuery;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareKey;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordAddLogEntity;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordDeleteLogEntity;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordShareEntity;
import com.nanri.aiimage.modules.keywordshare.model.entity.KeywordUsageEntity;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareAddRequest;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareDeleteRequest;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordShareSyncImportRequest;
import com.nanri.aiimage.modules.keywordshare.model.dto.KeywordUsageBatchRequest;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordSharePageVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareRowVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareSyncResultVo;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 五国关键词共享 Service 单测:列表筛选/状态过滤/排序契约、分页与 usedDays 归一化、
* mark 幂等、add 查重跳过 + 留痕 + 自动标记、delete 留痕、random、dup 计数。
*/
@ExtendWith(MockitoExtension.class)
class KeywordShareServiceTest {
private static final Long COMPANY_ID = 7L;
private static final String VIEWER = "阿华";
@Mock
private KeywordShareMapper keywordShareMapper;
@Mock
private KeywordUsageMapper keywordUsageMapper;
@Mock
private KeywordAddLogMapper keywordAddLogMapper;
@Mock
private KeywordDeleteLogMapper keywordDeleteLogMapper;
private KeywordShareService newService() {
return newService(new KeywordShareSyncProperties());
}
private KeywordShareService newService(KeywordShareSyncProperties syncProperties) {
return new KeywordShareService(keywordShareMapper, keywordUsageMapper,
keywordAddLogMapper, keywordDeleteLogMapper, syncProperties);
}
private static KeywordShareSyncProperties rosterOf(boolean strict, String... names) {
KeywordShareSyncProperties properties = new KeywordShareSyncProperties();
properties.setStrict(strict);
properties.setUsedUsers(List.of(names));
return properties;
}
private static KeywordShareRowVo row(long id, String keyword, boolean used, String usedUser) {
KeywordShareRowVo vo = new KeywordShareRowVo();
vo.setId(id);
vo.setCountry("英国");
vo.setKeyword(keyword);
vo.setChinese("翻译" + id);
vo.setUsed(used);
if (used) {
vo.setUsedTime(LocalDateTime.now().minusHours(id));
vo.setUsedUser(usedUser);
}
return vo;
}
// ---------------------------------------------------------------- 列表
@Test
@DisplayName("列表:命中数按用户筛选口径、命中内已使用数单独数一遍、dup 计数进统计条")
void pageComputesHitUsedUnusedAndDup() {
KeywordShareFilterQuery all = new KeywordShareFilterQuery();
all.setCompanyId(COMPANY_ID);
all.setStatus("all");
when(keywordShareMapper.countHit(any(KeywordShareFilterQuery.class))).thenReturn(10L, 4L);
when(keywordShareMapper.selectRows(any(KeywordShareFilterQuery.class))).thenReturn(List.of());
when(keywordShareMapper.countDupKeywords(COMPANY_ID)).thenReturn(3L);
KeywordSharePageVo vo = newService().page(COMPANY_ID, VIEWER, null, null, null, null, null,
null, "all", 0, false, 1L, 200L);
assertThat(vo.getTotal()).isEqualTo(10L);
assertThat(vo.getStats().getHit()).isEqualTo(10L);
assertThat(vo.getStats().getUsed()).isEqualTo(4L);
assertThat(vo.getStats().getUnused()).isEqualTo(6L);
assertThat(vo.getStats().getDup()).isEqualTo(3L);
// 第二次 countHit 是「命中内已使用数」,必须把 status 换成 used、其余条件原样
ArgumentCaptor<KeywordShareFilterQuery> captor = ArgumentCaptor.forClass(KeywordShareFilterQuery.class);
verify(keywordShareMapper, org.mockito.Mockito.times(2)).countHit(captor.capture());
assertThat(captor.getAllValues().get(0).getStatus()).isEqualTo("all");
assertThat(captor.getAllValues().get(1).getStatus()).isEqualTo("used");
assertThat(captor.getAllValues().get(1).getCompanyId()).isEqualTo(COMPANY_ID);
}
@Test
@DisplayName("列表:状态过滤 used/unused 时命中内已/未使用数直接由命中推导,不再多查一遍")
void pageWithActiveStatusFilterDerivesStats() {
when(keywordShareMapper.countHit(any(KeywordShareFilterQuery.class))).thenReturn(6L);
when(keywordShareMapper.selectRows(any(KeywordShareFilterQuery.class))).thenReturn(List.of());
when(keywordShareMapper.countDupKeywords(COMPANY_ID)).thenReturn(0L);
KeywordSharePageVo used = newService().page(COMPANY_ID, VIEWER, null, null, null, null, null,
null, "used", 0, false, 1L, 200L);
assertThat(used.getStats().getHit()).isEqualTo(6L);
assertThat(used.getStats().getUsed()).isEqualTo(6L);
assertThat(used.getStats().getUnused()).isZero();
KeywordSharePageVo unused = newService().page(COMPANY_ID, VIEWER, null, null, null, null, null,
null, "unused", 0, false, 1L, 200L);
assertThat(unused.getStats().getUsed()).isZero();
assertThat(unused.getStats().getUnused()).isEqualTo(6L);
// 状态过滤生效时不再为「命中内已使用数」多查一遍:两次 page 各查 1 次
verify(keywordShareMapper, org.mockito.Mockito.times(2)).countHit(any(KeywordShareFilterQuery.class));
}
@Test
@DisplayName("列表:筛选条件(类目/搜索/仅看我/usedDays)与分页进 Mapper 载体,size 上限 500")
void pageCarriesFilterAndNormalizedPaging() {
when(keywordShareMapper.countHit(any(KeywordShareFilterQuery.class))).thenReturn(0L);
when(keywordShareMapper.selectRows(any(KeywordShareFilterQuery.class))).thenReturn(List.of());
when(keywordShareMapper.countDupKeywords(COMPANY_ID)).thenReturn(0L);
newService().page(COMPANY_ID, VIEWER, " 英国 ", "厨房用品", "锅具", "煎锅", "平底锅",
" storage ", "all", 30, true, 0L, 1000L);
ArgumentCaptor<KeywordShareFilterQuery> captor = ArgumentCaptor.forClass(KeywordShareFilterQuery.class);
verify(keywordShareMapper).selectRows(captor.capture());
KeywordShareFilterQuery filter = captor.getValue();
assertThat(filter.getCountry()).isEqualTo("英国");
assertThat(filter.getCategory()).isEqualTo("厨房用品");
assertThat(filter.getSubCategory()).isEqualTo("锅具");
assertThat(filter.getCategoryL3()).isEqualTo("煎锅");
assertThat(filter.getCategoryL4()).isEqualTo("平底锅");
assertThat(filter.getSearch()).isEqualTo("storage");
assertThat(filter.getStatus()).isEqualTo("all");
assertThat(filter.getOnlyMine()).isTrue();
assertThat(filter.getUserName()).isEqualTo(VIEWER);
// usedDays=30:往前推 30 天
assertThat(filter.getUsedSince()).isNotNull();
assertThat(filter.getUsedSince()).isBefore(LocalDateTime.now());
assertThat(filter.getUsedSince()).isAfter(LocalDateTime.now().minusDays(31));
// 分页归一化:page=0→1、size=1000→500
assertThat(filter.getOffset()).isZero();
assertThat(filter.getLimit()).isEqualTo(500L);
}
@Test
@DisplayName("usedDays=1 表示「今天」:时间下限取当日零点;不传/0 表示不限")
void usedDaysOneMeansStartOfToday() {
when(keywordShareMapper.countHit(any(KeywordShareFilterQuery.class))).thenReturn(0L);
when(keywordShareMapper.selectRows(any(KeywordShareFilterQuery.class))).thenReturn(List.of());
when(keywordShareMapper.countDupKeywords(COMPANY_ID)).thenReturn(0L);
newService().page(COMPANY_ID, VIEWER, null, null, null, null, null, null, "all", 1, false, 1L, 200L);
ArgumentCaptor<KeywordShareFilterQuery> captor = ArgumentCaptor.forClass(KeywordShareFilterQuery.class);
verify(keywordShareMapper).selectRows(captor.capture());
assertThat(captor.getValue().getUsedSince()).isEqualTo(LocalDate.now().atStartOfDay());
newService().page(COMPANY_ID, VIEWER, null, null, null, null, null, null, "all", null, false, 1L, 200L);
verify(keywordShareMapper, org.mockito.Mockito.times(2)).selectRows(captor.capture());
assertThat(captor.getValue().getUsedSince()).isNull();
}
@Test
@DisplayName("列表:行按 Mapper 返回顺序透传(SQL 侧已按未使用在前、已使用按 used_time 升序排好),未使用行不带使用者")
void pageRowsKeepMapperOrderAndNormalizeUnusedRows() {
when(keywordShareMapper.countHit(any(KeywordShareFilterQuery.class))).thenReturn(3L);
when(keywordShareMapper.selectRows(any(KeywordShareFilterQuery.class))).thenReturn(List.of(
row(2, "kw-old-used", true, "张三"),
row(3, "kw-new-used", true, VIEWER),
row(1, "kw-unused", false, "不该有名字")));
when(keywordShareMapper.countDupKeywords(COMPANY_ID)).thenReturn(0L);
KeywordSharePageVo vo = newService().page(COMPANY_ID, VIEWER, null, null, null, null, null,
null, "all", 0, false, 1L, 200L);
assertThat(vo.getRows()).extracting(KeywordShareRowVo::getId).containsExactly(2L, 3L, 1L);
assertThat(vo.getRows().get(0).isUsed()).isTrue();
assertThat(vo.getRows().get(0).getUsedUser()).isEqualTo("张三");
assertThat(vo.getRows().get(2).isUsed()).isFalse();
assertThat(vo.getRows().get(2).getUsedTime()).isNull();
assertThat(vo.getRows().get(2).getUsedUser()).isEmpty();
}
@Test
@DisplayName("排序契约:Mapper XML 的 ORDER BY 必须是「已使用在前(对齐桌面版)、按 used_time 升序」,且禁止 ${} 拼接")
void mapperXmlKeepsSortContractAndPlaceholderOnly() throws Exception {
String xml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordShareMapper.xml"), StandardCharsets.UTF_8);
assertThat(xml).contains("ORDER BY (u.country IS NULL) ASC, u.used_time ASC");
assertThat(xml).doesNotContain("${");
String usageXml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordUsageMapper.xml"), StandardCharsets.UTF_8);
assertThat(usageXml).contains("ON DUPLICATE KEY UPDATE").doesNotContain("${");
}
// ---------------------------------------------------------------- 标记/取消使用
@Test
@DisplayName("mark:UPSERT 幂等——重复标记同一词两次结果一致,使用者与时间都取服务端当前值")
void markIsIdempotentWithServerTime() {
KeywordUsageBatchRequest request = new KeywordUsageBatchRequest();
KeywordUsageBatchRequest.Item item1 = new KeywordUsageBatchRequest.Item();
item1.setCountry("英国");
item1.setKeyword(" storage box ");
KeywordUsageBatchRequest.Item item2 = new KeywordUsageBatchRequest.Item();
item2.setCountry("德国");
item2.setKeyword("aufbewahrungsbox");
request.setItems(List.of(item1, item2));
KeywordShareService service = newService();
LocalDateTime before = LocalDateTime.now();
var first = service.mark(request, COMPANY_ID, VIEWER);
var second = service.mark(request, COMPANY_ID, VIEWER);
LocalDateTime after = LocalDateTime.now();
assertThat(first.getMarked()).isEqualTo(2);
assertThat(second.getMarked()).isEqualTo(2);
ArgumentCaptor<List<KeywordUsageEntity>> captor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper, org.mockito.Mockito.times(2)).upsertBatch(captor.capture());
List<KeywordUsageEntity> rows = captor.getAllValues().get(0);
assertThat(rows).hasSize(2);
assertThat(rows).allSatisfy(row -> {
assertThat(row.getCompanyId()).isEqualTo(COMPANY_ID);
assertThat(row.getUserName()).isEqualTo(VIEWER);
assertThat(row.getUsedTime()).isAfterOrEqualTo(before).isBeforeOrEqualTo(after);
});
assertThat(rows.get(0).getKeyword()).isEqualTo("storage box");
assertThat(rows.get(1).getCountry()).isEqualTo("德国");
}
@Test
@DisplayName("mark:批内重复键去重、空键跳过;全空时不动库")
void markSkipsBlankAndDuplicateKeys() {
KeywordUsageBatchRequest request = new KeywordUsageBatchRequest();
KeywordUsageBatchRequest.Item blank = new KeywordUsageBatchRequest.Item();
blank.setCountry("英国");
blank.setKeyword(" ");
KeywordUsageBatchRequest.Item dup = new KeywordUsageBatchRequest.Item();
dup.setCountry("英国");
dup.setKeyword("box");
KeywordUsageBatchRequest.Item dupAgain = new KeywordUsageBatchRequest.Item();
dupAgain.setCountry(" 英国 ");
dupAgain.setKeyword("box");
request.setItems(List.of(blank, dup, dupAgain));
var result = newService().mark(request, COMPANY_ID, VIEWER);
assertThat(result.getMarked()).isEqualTo(1);
@SuppressWarnings("unchecked")
ArgumentCaptor<List<KeywordUsageEntity>> captor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper).upsertBatch(captor.capture());
assertThat(captor.getValue()).hasSize(1);
assertThat(captor.getValue().get(0).getKeyword()).isEqualTo("box");
KeywordUsageBatchRequest allBlank = new KeywordUsageBatchRequest();
KeywordUsageBatchRequest.Item item = new KeywordUsageBatchRequest.Item();
item.setKeyword(" ");
allBlank.setItems(List.of(item));
assertThat(newService().mark(allBlank, COMPANY_ID, VIEWER).getMarked()).isZero();
}
@Test
@DisplayName("unmark:按 (company, country, keyword) 删行,返回实际删除条数")
void unmarkDeletesRowsAndCountsAffected() {
KeywordUsageBatchRequest request = new KeywordUsageBatchRequest();
KeywordUsageBatchRequest.Item item = new KeywordUsageBatchRequest.Item();
item.setCountry("英国");
item.setKeyword("box");
request.setItems(List.of(item));
when(keywordUsageMapper.deleteBatch(eq(COMPANY_ID), anyList())).thenReturn(1);
var result = newService().unmark(request, COMPANY_ID);
assertThat(result.getUnmarked()).isEqualTo(1);
@SuppressWarnings("unchecked")
ArgumentCaptor<List<KeywordShareKey>> captor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper).deleteBatch(eq(COMPANY_ID), captor.capture());
assertThat(captor.getValue().get(0).getKeyword()).isEqualTo("box");
}
// ---------------------------------------------------------------- 添加
@Test
@DisplayName("add:查重跳过已存在词,空词/批内重复跳过;成功行写词本体 + 添加留痕 + 自动标记已使用")
void addSkipsExistingAndBlankAndWritesLogsAndAutoMarks() {
KeywordShareAddRequest request = new KeywordShareAddRequest();
KeywordShareAddRequest.Item good = new KeywordShareAddRequest.Item();
good.setCountry("英国");
good.setKeyword(" storage box ");
good.setChinese("收纳盒");
KeywordShareAddRequest.Item existing = new KeywordShareAddRequest.Item();
existing.setCountry("德国");
existing.setKeyword("aufbewahrungsbox");
existing.setChinese("收纳箱");
KeywordShareAddRequest.Item blank = new KeywordShareAddRequest.Item();
blank.setCountry("法国");
blank.setKeyword(" ");
KeywordShareAddRequest.Item dup = new KeywordShareAddRequest.Item();
dup.setCountry("英国");
dup.setKeyword("storage box");
request.setItems(List.of(good, existing, blank, dup));
KeywordShareKey existingKey = KeywordShareKey.of("德国", "aufbewahrungsbox");
when(keywordShareMapper.selectExistingKeywords(eq(COMPANY_ID), anyList())).thenReturn(List.of(existingKey));
LocalDateTime before = LocalDateTime.now();
var result = newService().add(request, COMPANY_ID, VIEWER);
assertThat(result.getAdded()).isEqualTo(1);
assertThat(result.getSkipped()).isEqualTo(3);
@SuppressWarnings("unchecked")
ArgumentCaptor<List<KeywordShareEntity>> insertCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordShareMapper).insertBatchIgnore(insertCaptor.capture());
KeywordShareEntity inserted = insertCaptor.getValue().get(0);
assertThat(inserted.getCountry()).isEqualTo("英国");
assertThat(inserted.getKeyword()).isEqualTo("storage box");
assertThat(inserted.getChinese()).isEqualTo("收纳盒");
assertThat(inserted.getKtype()).isEqualTo("主关键词");
assertThat(inserted.getSource()).isEqualTo("手动添加");
assertThat(inserted.getCompanyId()).isEqualTo(COMPANY_ID);
assertThat(inserted.getUserName()).isEqualTo(VIEWER);
assertThat(inserted.getAddTime()).isAfterOrEqualTo(before);
@SuppressWarnings("unchecked")
ArgumentCaptor<List<KeywordAddLogEntity>> logCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordAddLogMapper).insertBatch(logCaptor.capture());
assertThat(logCaptor.getValue()).hasSize(1);
assertThat(logCaptor.getValue().get(0).getKeyword()).isEqualTo("storage box");
assertThat(logCaptor.getValue().get(0).getUserName()).isEqualTo(VIEWER);
@SuppressWarnings("unchecked")
ArgumentCaptor<List<KeywordUsageEntity>> usageCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper).upsertBatch(usageCaptor.capture());
assertThat(usageCaptor.getValue()).hasSize(1);
assertThat(usageCaptor.getValue().get(0).getKeyword()).isEqualTo("storage box");
assertThat(usageCaptor.getValue().get(0).getUserName()).isEqualTo(VIEWER);
}
@Test
@DisplayName("add:全部跳过时不动任何表(词本体/留痕/使用状态都不写)")
void addWithNothingToAddTouchesNothing() {
KeywordShareAddRequest request = new KeywordShareAddRequest();
KeywordShareAddRequest.Item blank = new KeywordShareAddRequest.Item();
blank.setCountry("英国");
blank.setKeyword("");
request.setItems(List.of(blank));
var result = newService().add(request, COMPANY_ID, VIEWER);
assertThat(result.getAdded()).isZero();
assertThat(result.getSkipped()).isEqualTo(1);
verify(keywordShareMapper, never()).insertBatchIgnore(anyList());
verify(keywordAddLogMapper, never()).insertBatch(anyList());
verify(keywordUsageMapper, never()).upsertBatch(anyList());
verify(keywordShareMapper, never()).selectExistingKeywords(any(), anyList());
}
// ---------------------------------------------------------------- 删除
@Test
@DisplayName("delete:只删本公司存在的行并逐行写删除留痕(谁删了哪个词可追溯)")
void deleteWritesDeleteLogForCompanyRows() {
KeywordShareDeleteRequest request = new KeywordShareDeleteRequest();
request.setIds(List.of(1L, 2L, 999L));
KeywordShareEntity row1 = new KeywordShareEntity();
row1.setId(1L);
row1.setCountry("英国");
row1.setKeyword("box");
row1.setCompanyId(COMPANY_ID);
KeywordShareEntity row2 = new KeywordShareEntity();
row2.setId(2L);
row2.setCountry("德国");
row2.setKeyword("kiste");
row2.setCompanyId(COMPANY_ID);
KeywordShareEntity foreign = new KeywordShareEntity();
foreign.setId(999L);
foreign.setCountry("法国");
foreign.setKeyword("mot-etranger");
foreign.setCompanyId(8L);
when(keywordShareMapper.selectBatchIds(List.of(1L, 2L, 999L))).thenReturn(List.of(row1, row2, foreign));
LocalDateTime before = LocalDateTime.now();
var result = newService().delete(request, COMPANY_ID, VIEWER);
// 公司隔离:999 号行是别家公司的,即使 id 在请求里也绝不能删
assertThat(result.getDeleted()).isEqualTo(2);
verify(keywordShareMapper).deleteBatchIds(List.of(1L, 2L));
@SuppressWarnings("unchecked")
ArgumentCaptor<List<KeywordDeleteLogEntity>> logCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordDeleteLogMapper).insertBatch(logCaptor.capture());
List<KeywordDeleteLogEntity> logs = logCaptor.getValue();
assertThat(logs).hasSize(2);
assertThat(logs).extracting(KeywordDeleteLogEntity::getKeyword).containsExactly("box", "kiste");
assertThat(logs).allSatisfy(log -> {
assertThat(log.getCompanyId()).isEqualTo(COMPANY_ID);
assertThat(log.getUserName()).isEqualTo(VIEWER);
assertThat(log.getDeleteTime()).isAfterOrEqualTo(before);
});
}
@Test
@DisplayName("delete:请求里的行都不属于本公司(或不存在)时,不动库也不留痕")
void deleteWithNoCompanyRowsTouchesNothing() {
KeywordShareDeleteRequest request = new KeywordShareDeleteRequest();
request.setIds(List.of(1L));
when(keywordShareMapper.selectBatchIds(anyList())).thenReturn(List.of());
var result = newService().delete(request, COMPANY_ID, VIEWER);
assertThat(result.getDeleted()).isZero();
verify(keywordShareMapper, never()).deleteBatchIds(anyList());
verify(keywordDeleteLogMapper, never()).insertBatch(anyList());
}
// ---------------------------------------------------------------- 随机抽词
@Test
@DisplayName("random:只从「未使用」池抽,条数默认 10、上限 100、下限 1")
void randomUsesUnusedPoolWithClampedCount() {
when(keywordShareMapper.selectRandomUnused(any(KeywordShareFilterQuery.class))).thenReturn(List.of(
row(5, "kw-random", false, "")));
var result = newService().random(COMPANY_ID, VIEWER, "英国", null, null, null, null, null, 5L);
assertThat(result).hasSize(1);
assertThat(result.get(0).getKeyword()).isEqualTo("kw-random");
ArgumentCaptor<KeywordShareFilterQuery> captor = ArgumentCaptor.forClass(KeywordShareFilterQuery.class);
verify(keywordShareMapper).selectRandomUnused(captor.capture());
assertThat(captor.getValue().getStatus()).isEqualTo("unused");
assertThat(captor.getValue().getLimit()).isEqualTo(5L);
assertThat(captor.getValue().getCountry()).isEqualTo("英国");
newService().random(COMPANY_ID, VIEWER, null, null, null, null, null, null, null);
verify(keywordShareMapper, org.mockito.Mockito.times(2)).selectRandomUnused(captor.capture());
assertThat(captor.getValue().getLimit()).isEqualTo(KeywordShareService.DEFAULT_RANDOM_COUNT);
newService().random(COMPANY_ID, VIEWER, null, null, null, null, null, null, 1000L);
verify(keywordShareMapper, org.mockito.Mockito.times(3)).selectRandomUnused(captor.capture());
assertThat(captor.getValue().getLimit()).isEqualTo(KeywordShareService.MAX_RANDOM_COUNT);
}
// ---------------------------------------------------------------- 防回流的供应商隔离自检
@Test
@DisplayName("公司隔离:全部 Mapper 写路径的第一个参数都是服务端给的 companyId(抽查写 SQL 收口)")
void writeSqlStaysInMapperLayerWithCompanyScope() throws Exception {
String shareXml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordShareMapper.xml"), StandardCharsets.UTF_8);
// 词本体的读路径一律带 company_id 条件(含 dup 子查询与类目名册)
long scopedSelects = shareXml.lines().filter(line -> line.contains("company_id = #{")).count();
assertThat(scopedSelects).isGreaterThanOrEqualTo(5);
String usageXml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordUsageMapper.xml"), StandardCharsets.UTF_8);
assertThat(usageXml).contains("company_id = #{companyId}");
String addXml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordAddLogMapper.xml"), StandardCharsets.UTF_8);
String deleteXml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordDeleteLogMapper.xml"), StandardCharsets.UTF_8);
assertThat(addXml + deleteXml)
.contains("company_id", "user_name")
.doesNotContain("${");
}
// ---------------------------------------------------------------- 客户端全量同步
private static KeywordShareSyncImportRequest.Item syncItem(String country, String keyword, Boolean used,
String usedUser, String usedTime) {
KeywordShareSyncImportRequest.Item item = new KeywordShareSyncImportRequest.Item();
item.setCountry(country);
item.setKeyword(keyword);
item.setUsed(used);
item.setUsedUser(usedUser);
item.setUsedTime(usedTime);
return item;
}
private static KeywordShareSyncImportRequest syncRequest(List<KeywordShareSyncImportRequest.Item> items) {
KeywordShareSyncImportRequest request = new KeywordShareSyncImportRequest();
request.setItems(items);
return request;
}
@Test
@DisplayName("sync/import:客户端传来的 usedTime/usedUser 与四级类目原样落库,不被服务端此刻与账号覆盖")
void syncImportKeepsClientUsedTimeUserAndCategories() {
KeywordShareSyncImportRequest.Item item = syncItem("英国", "wraps", true, "阿武(吴棋龙)", "2026-10-25T22:59:26");
item.setChinese("包裹");
item.setCategory("衣物鞋类");
item.setSubCategory("包包");
item.setCategoryL3("其他包包");
item.setCategoryL4("其他包包");
item.setKtype("主关键词");
item.setSource("本地导入");
KeywordShareService service = newService(rosterOf(true, "阿武(吴棋龙)"));
LocalDateTime before = LocalDateTime.now();
KeywordShareSyncResultVo vo = service.syncImport(syncRequest(List.of(item)), COMPANY_ID, "kw_share_api");
// 这条用例存在的理由:mark() 走的是 used_time=now()、user_name=token 账号,
// 同步历史时会被改写成「谁在同步那一刻用的」,真实使用人与使用时刻双双丢失。
ArgumentCaptor<List<KeywordUsageEntity>> usageCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper).upsertBatch(usageCaptor.capture());
KeywordUsageEntity usage = usageCaptor.getValue().get(0);
assertThat(usage.getUserName()).isEqualTo("阿武(吴棋龙)");
assertThat(usage.getUsedTime()).isEqualTo(LocalDateTime.of(2026, 10, 25, 22, 59, 26))
.isBefore(before);
assertThat(usage.getCompanyId()).isEqualTo(COMPANY_ID);
ArgumentCaptor<List<KeywordShareEntity>> wordCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordShareMapper).upsertBatchFromSync(wordCaptor.capture());
KeywordShareEntity word = wordCaptor.getValue().get(0);
assertThat(word.getCategory()).isEqualTo("衣物鞋类");
assertThat(word.getSubCategory()).isEqualTo("包包");
assertThat(word.getCategoryL3()).isEqualTo("其他包包");
// 词本体的 user_name 是「添加人」,新词就是本次同步账号——它和使用人是两回事
assertThat(word.getUserName()).isEqualTo("kw_share_api");
assertThat(vo.getAdded()).isEqualTo(1);
assertThat(vo.getUpdated()).isZero();
assertThat(vo.getUsedUserFallback()).isZero();
assertThat(vo.getUsedUserUnknown()).isZero();
assertThat(vo.getUsedTimeFallback()).isZero();
}
@Test
@DisplayName("sync/import:名单外姓名 strict=true 回退账号名并计数,strict=false 放行但仍计 unknown")
void syncImportResolvesOperatorAgainstRoster() {
// 半角括号写法要能命中全角名单,否则同一个人会被后管拆成两个使用者
KeywordShareSyncImportRequest.Item hit = syncItem("英国", "basket", true, "阿武(吴棋龙)", "2026-10-01 08:00:00");
KeywordShareSyncImportRequest.Item miss = syncItem("英国", "hanger", true, "陌生人", "2026-10-01 08:00:00");
ArgumentCaptor<List<KeywordUsageEntity>> captor = ArgumentCaptor.forClass(List.class);
KeywordShareSyncResultVo strict = newService(rosterOf(true, "阿武(吴棋龙)"))
.syncImport(syncRequest(List.of(hit, miss)), COMPANY_ID, "kw_share_api");
verify(keywordUsageMapper).upsertBatch(captor.capture());
// 命中名单后落的是名单里那份写法:客户端传半角也不能让它把同一个人拆成两个使用者
assertThat(captor.getValue()).extracting(KeywordUsageEntity::getUserName)
.containsExactly("阿武(吴棋龙)", "kw_share_api");
assertThat(strict.getUsedUserFallback()).isEqualTo(1);
assertThat(strict.getUsedUserUnknown()).isEqualTo(1);
KeywordShareSyncResultVo lenient = newService(rosterOf(false, "阿武(吴棋龙)"))
.syncImport(syncRequest(List.of(hit, miss)), COMPANY_ID, "kw_share_api");
assertThat(lenient.getUsedUserFallback()).isZero();
assertThat(lenient.getUsedUserUnknown()).isEqualTo(1);
}
@Test
@DisplayName("sync/import:脏时间按行降级——1970 丢使用状态但词照收、未来值钳到此刻、缺失回退此刻")
void syncImportDegradesDirtyUsedTimePerRow() {
KeywordShareSyncImportRequest.Item ancient = syncItem("英国", "ancient", true, "阿武(吴棋龙)", "1970-01-01T00:00:00");
KeywordShareSyncImportRequest.Item future = syncItem("英国", "future", true, "阿武(吴棋龙)", "2099-01-01T00:00:00");
KeywordShareSyncImportRequest.Item missing = syncItem("英国", "missing", true, "阿武(吴棋龙)", " ");
KeywordShareSyncImportRequest.Item unparsable = syncItem("英国", "garbage", true, "阿武(吴棋龙)", "昨天下午");
LocalDateTime before = LocalDateTime.now();
KeywordShareSyncResultVo vo = newService(rosterOf(true, "阿武(吴棋龙)"))
.syncImport(syncRequest(List.of(ancient, future, missing, unparsable)), COMPANY_ID, "kw_share_api");
assertThat(vo.getUsageSkipped()).isEqualTo(1);
assertThat(vo.getUsedTimeClamped()).isEqualTo(1);
assertThat(vo.getUsedTimeFallback()).isEqualTo(2);
// 一颗脏时间戳不该打掉整批:四个词全部入库,只有 ancient 的使用状态被丢
assertThat(vo.getAdded()).isEqualTo(4);
ArgumentCaptor<List<KeywordShareEntity>> wordCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordShareMapper).upsertBatchFromSync(wordCaptor.capture());
assertThat(wordCaptor.getValue()).extracting(KeywordShareEntity::getKeyword)
.containsExactly("ancient", "future", "missing", "garbage");
ArgumentCaptor<List<KeywordUsageEntity>> usageCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper).upsertBatch(usageCaptor.capture());
assertThat(usageCaptor.getValue()).hasSize(3)
.allSatisfy(row -> assertThat(row.getUsedTime()).isAfterOrEqualTo(before));
}
@Test
@DisplayName("sync/import:used=false 删使用记录;dryRun 只统计不写;空键与批内重复计入 skipped")
void syncImportDeletesUsageAndHonoursDryRun() {
List<KeywordShareSyncImportRequest.Item> items = List.of(
syncItem("英国", "keep", false, null, null),
syncItem("英国", "drop", true, "阿武(吴棋龙)", "2026-10-01T08:00:00"),
syncItem("英国", "drop", true, "阿武(吴棋龙)", "2026-10-01T08:00:00"),
syncItem("", "no-country", true, "阿武(吴棋龙)", "2026-10-01T08:00:00"));
KeywordShareSyncImportRequest request = syncRequest(items);
KeywordShareService service = newService(rosterOf(true, "阿武(吴棋龙)"));
KeywordShareSyncImportRequest dryRunRequest = syncRequest(items);
dryRunRequest.setDryRun(true);
KeywordShareSyncResultVo dryRun = service.syncImport(dryRunRequest, COMPANY_ID, "kw_share_api");
assertThat(dryRun.isDryRun()).isTrue();
assertThat(dryRun.getSkipped()).isEqualTo(2);
assertThat(dryRun.getAdded()).isEqualTo(2);
verify(keywordShareMapper, never()).upsertBatchFromSync(anyList());
verify(keywordUsageMapper, never()).upsertBatch(anyList());
verify(keywordUsageMapper, never()).deleteBatch(any(), anyList());
KeywordShareSyncResultVo real = service.syncImport(request, COMPANY_ID, "kw_share_api");
assertThat(real.isDryRun()).isFalse();
ArgumentCaptor<List<KeywordShareKey>> deleteCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper).deleteBatch(eq(COMPANY_ID), deleteCaptor.capture());
assertThat(deleteCaptor.getValue()).extracting(KeywordShareKey::getKeyword).containsExactly("keep");
assertThat(real.getUsageDeleted()).isEqualTo(1);
}
@Test
@DisplayName("sync/import:used 不传=不碰使用状态(只同步词库不能把后台已有使用记录删掉)")
void syncImportLeavesUsageUntouchedWhenUsedFlagOmitted() {
KeywordShareSyncImportRequest.Item wordOnly = syncItem("英国", "wraps", null, null, null);
wordOnly.setCategory("衣物鞋类");
KeywordShareSyncResultVo vo = newService(rosterOf(true, "阿武(吴棋龙)"))
.syncImport(syncRequest(List.of(wordOnly)), COMPANY_ID, "kw_share_api");
assertThat(vo.getAdded()).isEqualTo(1);
assertThat(vo.getUsageUpserted()).isZero();
assertThat(vo.getUsageDeleted()).isZero();
verify(keywordUsageMapper, never()).upsertBatch(anyList());
verify(keywordUsageMapper, never()).deleteBatch(any(), anyList());
ArgumentCaptor<List<KeywordShareEntity>> captor = ArgumentCaptor.forClass(List.class);
verify(keywordShareMapper).upsertBatchFromSync(captor.capture());
assertThat(captor.getValue().get(0).getCategory()).isEqualTo("衣物鞋类");
}
@Test
@DisplayName("sync/import:写侧按 500 行分片,不把整批塞进一条 SQL 的占位符里")
void syncImportShardsWrites() {
List<KeywordShareSyncImportRequest.Item> items = new java.util.ArrayList<>();
for (int i = 0; i < 1200; i++) {
items.add(syncItem("英国", "kw-" + i, true, "阿武(吴棋龙)", "2026-10-01T08:00:00"));
}
KeywordShareSyncResultVo vo = newService(rosterOf(true, "阿武(吴棋龙)"))
.syncImport(syncRequest(items), COMPANY_ID, "kw_share_api");
assertThat(vo.getAdded()).isEqualTo(1200);
ArgumentCaptor<List<KeywordShareEntity>> wordCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordShareMapper, org.mockito.Mockito.times(3)).upsertBatchFromSync(wordCaptor.capture());
assertThat(wordCaptor.getAllValues()).extracting(List::size).containsExactly(500, 500, 200);
ArgumentCaptor<List<KeywordUsageEntity>> usageCaptor = ArgumentCaptor.forClass(List.class);
verify(keywordUsageMapper, org.mockito.Mockito.times(3)).upsertBatch(usageCaptor.capture());
assertThat(usageCaptor.getAllValues()).extracting(List::size).containsExactly(500, 500, 200);
}
@Test
@DisplayName("sync/import 的 UPSERT SQL:类目非空才覆盖,且更新分支不得改写添加人与添加时间")
void syncUpsertKeepsCategoriesAndProvenance() throws Exception {
String xml = Files.readString(Path.of(
"src/main/resources/mapper/keywordshare/KeywordShareMapper.xml"), StandardCharsets.UTF_8);
String upsert = xml.substring(xml.indexOf("<insert id=\"upsertBatchFromSync\">"));
assertThat(upsert).contains("ON DUPLICATE KEY UPDATE")
.contains("category = COALESCE(NULLIF(VALUES(category), ''), category)")
.contains("sub_category = COALESCE(NULLIF(VALUES(sub_category), ''), sub_category)")
.doesNotContain("${");
// 更新分支只碰类目/释义/类型/来源:user_name、add_time 是历史归属,同步无权改写
String updateBranch = upsert.substring(upsert.indexOf("ON DUPLICATE KEY UPDATE"));
assertThat(updateBranch).doesNotContain("user_name =")
.doesNotContain("add_time =");
}
}
@@ -25,7 +25,7 @@ import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* AC-19(R8/审计 P1-B1、P1-B2、P1-B3、P1-B4):任务中心时间窗+keyset、关键词去 RAND、
* AC-19(R8/审计 P1-B1、P1-B3、P1-B4):任务中心时间窗+keyset、
* 心跳瘦字段、权限菜单短 TTL 缓存。
*
* <p>逐条证据:
@@ -35,8 +35,6 @@ import static org.mockito.Mockito.when;
* {@code ORDER BY m.createdAt DESC, m.id DESC LIMIT #{limit} OFFSET #{offset}},
* 而 {@code TaskCenterQueryService.tasks()}(:110-139)把 {@code startTime/endTime}
* 原样透传、服务层不填默认窗口 ⇒ 不带时间参数就是全历史 UNION + 深 OFFSET。</li>
* <li><b>P1-B2</b> {@code mapper/keywordshare/KeywordShareMapper.xml:53} 的
* {@code selectRandomUnused} 是 {@code ORDER BY RAND()}(全表 filesort)。</li>
* <li><b>P1-B3</b> {@code TaskHeartbeatService.java:111-116} 的 {@code selectFileTask}
* 没有 {@code .select(...)},捞整行 {@code FileTaskEntity}(含
* {@code requestJson}/{@code resultJson}),而心跳只用
@@ -82,16 +80,6 @@ class PendingPhase5ReadPathTest {
.containsAnyOf("DEFAULT_WINDOW", "minusDays", "startOfDefaultWindow");
}
@Test
void 关键词抽词不许再_ORDER_BY_RAND() throws Exception {
String body = MapperXmlSupport.statementBody(
com.nanri.aiimage.modules.keywordshare.mapper.KeywordShareMapper.class, "selectRandomUnused");
assertThat(body)
.as("P1-B2:ORDER BY RAND() 对全表 filesort;要么先 count 取随机 offset,要么物化 used 标记")
.doesNotContain("RAND()");
}
@Test
void 心跳取任务必须只读瘦字段() {
String service = SourceScan.withoutComments(SourceScan.sourceText("TaskHeartbeatService.java"));