feat(keywordshare): 五国关键词共享后端模块(桌面工具网页化)

词本体直接读写主库既有 keyword_share 表(已是全量词库),使用状态
keyword_usage,留痕 keyword_add_log/keyword_delete_log;不建新表、无 SQLite。
九个端点挂 /api/keyword-share,权限键 keyword-share,companyId 服务端取。
列表排序对齐桌面版:已使用在前、按 used_time 升序;添加查重跳过+留痕+
自动标记已使用;随机抽词从未使用池。
SQL 账本 99→115(16 条新写语句)、select 账本 67→78(11 条),逐条点入
NOT_MIGRATED;ApiGuardCoverageAuditor METHOD_GUARDED_PATHS 登记
/api/keyword-share(9 端点全部 handler 内 requireConsolePageAccess 把门)。
FILTER_* 命名避开任务状态词表棘轮。
This commit is contained in:
2026-10-23 21:54:52 +08:00
parent 6d9d4b98b2
commit 2d408199d6
38 changed files with 2077 additions and 4 deletions
@@ -56,7 +56,9 @@ class MigratedSqlEquivalenceTest {
private static final int LEDGER_SELECTS = 60;
/** 全部 mapper XML 里的 select 总数:账本 60 + TaskImageCache 5 + AsinResultCache 1。 */
/** 66 → 67:会话容忍新增的 {@code AdminUserMapper#countLiveWorkFor} 也是一条 select。 */
private static final int XML_SELECT_TOTAL = 67;
// 67 → 78:keywordshare 模块新写 11 条 select,逐条登记进下方 NOT_MIGRATED
// (与 SqlLayeringConventionTest.XML_STATEMENT_TOTAL 同轮 99 → 115)。
private static final int XML_SELECT_TOTAL = 78;
/**
* 不是「从注解搬过来」的语句:注解时代没有原文可对撞,等价性这支只能跳过它们。
@@ -68,7 +70,19 @@ class MigratedSqlEquivalenceTest {
// 与 increment 分两条是口径要求(计次先于响应、token 只在响应后有读数),不是随手加的第二条 SQL。
"UserSecretUsageMapper#addTokens",
// 失败任务重试:INSERT ... SELECT 复制采集明细行,非注解迁移件。
"CollectDataItemMapper#copyItemsForRetry");
"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");
/** 账本 5 列:接口 / 方法 / @Select 种类 / 是否含常量插值 / 注解原文(Java 反转义后那条串)。 */
private static final int LEDGER_COLUMNS = 5;
@@ -72,7 +72,9 @@ class SqlLayeringConventionTest {
// 计次发生在发请求之前(含重试),token 只有响应回来才有读数,合成一条 upsert 就会漏计超时的那次。
// 98 → 99:失败任务重试新增 {@code CollectDataItemMapper#copyItemsForRetry}
// (INSERT ... SELECT 复制明细行),同样登记进 NOT_MIGRATED。
private static final int XML_STATEMENT_TOTAL = 99;
// 99 → 115:keywordshare 模块(五国关键词共享网页化,5 份 XML 16 条)新写语句,
// 11 条 select 逐条登记进 MigratedSqlEquivalenceTest.NOT_MIGRATED(与本格同轮 67 → 78)。
private static final int XML_STATEMENT_TOTAL = 115;
/**
* wrapper 里夹带函数级 SQL 的现状("这不是简单单表"的证据),文件名 → 条数:
@@ -0,0 +1,479 @@
package com.nanri.aiimage.modules.keywordshare.service;
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.KeywordUsageBatchRequest;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordSharePageVo;
import com.nanri.aiimage.modules.keywordshare.model.vo.KeywordShareRowVo;
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 new KeywordShareService(keywordShareMapper, keywordUsageMapper,
keywordAddLogMapper, keywordDeleteLogMapper);
}
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("${");
}
}