presignPackage(String fileName, String version) {
String normalizedName = requireZipFileName(fileName);
@@ -155,6 +184,11 @@ public class WorkbenchClientPackageService {
/**
* 直传确认:校验对象存在、大小上限、版本号与对象名一致,服务端复算 sha256 后落库。
* sha256 为空或长度不对直接拒绝——宁可让管理员重传,也不让客户端拿到没有锚点的包。
+ *
CR-02:落库前把对象流式落到临时文件、用 {@link ZipFile} 只读扫描条目名;
+ * 包内出现 {@code kw_share_cfg.json}、{@code .env}、{@code *.pem}、{@code *.key}
+ * 等凭据文件即拒绝并清理已上传对象,避免公开桶里出现带口令的安装包。
+ *
CR-05:同 objectKey 并发 confirm 幂等返回已登记行;同 version 不同 objectKey
+ * 由数据库唯一键 {@code uk_workbench_client_version} 兜底,冲突时清理对象并返回业务错误。
*/
public Map confirmPackage(String objectKey, String fileName, String version) {
if (objectKey == null || !objectKey.startsWith(OBJECT_KEY_PREFIX)) {
@@ -170,10 +204,7 @@ public class WorkbenchClientPackageService {
throw new BusinessException("版本号与上传对象不匹配,请重新上传");
}
// 幂等:重复 confirm 同一对象返回已登记行,不再报错(CR-08)
- WorkbenchClientPackageEntity existing = packageMapper.selectOne(
- new LambdaQueryWrapper()
- .eq(WorkbenchClientPackageEntity::getObjectKey, objectKey)
- .last("LIMIT 1"));
+ WorkbenchClientPackageEntity existing = findByObjectKey(objectKey);
if (existing != null) {
log.info("[workbench-client] 直传确认幂等命中 id={} objectKey={}", existing.getId(), objectKey);
return toItemMap(existing);
@@ -197,9 +228,11 @@ public class WorkbenchClientPackageService {
Long sameVersion = packageMapper.selectCount(new LambdaQueryWrapper()
.eq(WorkbenchClientPackageEntity::getVersion, normalizedVersion));
if (sameVersion != null && sameVersion > 0) {
- // 同版本不同字节会让已升级的装机按版本号比较后不升级,客户端还会拿到错误摘要
+ // 同版本不同字节会让已升级的装机按版本号比较后不升级,客户端还会拿到错误摘要。
+ // 拒绝时必须清理对象:512MB 级残留留在公开桶可被反复触发耗存储(CR-05)。
log.warn("[workbench-client] 直传确认失败:版本已存在 version={} objectKey={}",
normalizedVersion, objectKey);
+ removeRejectedObject(objectKey);
throw new BusinessException("该版本已存在,请提升版本号或先删除旧包");
}
WorkbenchClientPackageEntity latest = newest();
@@ -207,8 +240,11 @@ public class WorkbenchClientPackageService {
// 按上传时间取最新时,低版本后传会顶掉当前更新目标,已升级装机反而被判"无需更新"
log.warn("[workbench-client] 直传确认失败:版本低于当前最新 version={} latest={} objectKey={}",
normalizedVersion, latest.getVersion(), objectKey);
+ removeRejectedObject(objectKey);
throw new BusinessException("版本号不能低于当前最新版本 " + latest.getVersion());
}
+ // 内容检查排在版本/大小之后:先做便宜判定,避免为大包白下载一遍
+ rejectCredentialFiles(objectKey);
String sha256 = ossStorageService.workbenchClientObjectSha256(objectKey);
if (sha256 == null || sha256.length() != 64) {
log.warn("[workbench-client] 直传确认失败:摘要计算异常 objectKey={} sha256={}", objectKey, sha256);
@@ -221,13 +257,124 @@ public class WorkbenchClientPackageService {
entity.setObjectKey(objectKey);
entity.setFileSize(size);
entity.setSha256(sha256);
- packageMapper.insert(entity);
+ try {
+ packageMapper.insert(entity);
+ } catch (DuplicateKeyException duplicate) {
+ // 同 objectKey 并发 confirm:另一线程已登记,按幂等返回(CR-05)
+ WorkbenchClientPackageEntity concurrent = findByObjectKey(objectKey);
+ if (concurrent != null) {
+ log.info("[workbench-client] 并发直传确认幂等命中 id={} objectKey={}",
+ concurrent.getId(), objectKey);
+ return toItemMap(concurrent);
+ }
+ // 同 version 不同 objectKey:唯一键 uk_workbench_client_version 拦下后一行
+ log.warn("[workbench-client] 直传确认失败:版本并发冲突 version={} objectKey={}",
+ normalizedVersion, objectKey);
+ removeRejectedObject(objectKey);
+ throw new BusinessException("该版本已存在,请提升版本号或先删除旧包");
+ }
log.info("[workbench-client] 客户端包登记成功 id={} version={} fileName={} bytes={} sha256={}",
entity.getId(), normalizedVersion, normalizedName, size, sha256);
WorkbenchClientPackageEntity saved = packageMapper.selectById(entity.getId());
return toItemMap(saved == null ? entity : saved);
}
+ private WorkbenchClientPackageEntity findByObjectKey(String objectKey) {
+ return packageMapper.selectOne(new LambdaQueryWrapper()
+ .eq(WorkbenchClientPackageEntity::getObjectKey, objectKey)
+ .last("LIMIT 1"));
+ }
+
+ /**
+ * 发布前内容检查:把对象流式落到临时文件,只读扫描 zip 条目名。
+ *
+ * 不整包读入内存、不解压内容;{@link ZipFile} 只读中央目录。命中凭据文件或
+ * 非法 zip 时删除已上传对象,确保公开桶里不会留下不可登记的大对象。
+ */
+ private void rejectCredentialFiles(String objectKey) {
+ Path packageFile = ossStorageService.downloadWorkbenchClientObjectToTempFile(objectKey);
+ try (ZipFile zipFile = new ZipFile(packageFile.toFile())) {
+ Enumeration extends ZipEntry> entries = zipFile.entries();
+ int scanned = 0;
+ while (entries.hasMoreElements()) {
+ ZipEntry entry = entries.nextElement();
+ if (++scanned > MAX_ZIP_ENTRIES) {
+ log.warn("[workbench-client] 直传确认拒绝:zip 条目数超限 objectKey={} limit={}",
+ objectKey, MAX_ZIP_ENTRIES);
+ removeRejectedObject(objectKey);
+ throw new BusinessException("安装包内文件条目过多,请重新打包上传");
+ }
+ if (entry.isDirectory()) {
+ continue;
+ }
+ String baseName = baseName(entry.getName());
+ if (isCredentialFileName(baseName)) {
+ log.warn("[workbench-client] 直传确认拒绝:安装包含凭据文件 objectKey={} entry={}",
+ objectKey, entry.getName());
+ removeRejectedObject(objectKey);
+ throw new BusinessException("安装包内含凭据配置文件(" + baseName
+ + "),禁止发布,请移除后重新打包上传");
+ }
+ }
+ } catch (BusinessException ex) {
+ throw ex;
+ } catch (IOException ex) {
+ log.warn("[workbench-client] 直传确认失败:安装包不是有效 zip objectKey={} err={}",
+ objectKey, ex.getMessage());
+ removeRejectedObject(objectKey);
+ throw new BusinessException("上传的安装包不是有效的 zip 文件,请重新打包上传");
+ } finally {
+ deleteTempQuietly(packageFile);
+ }
+ }
+
+ private static String baseName(String entryName) {
+ if (entryName == null) {
+ return "";
+ }
+ String normalized = entryName.replace('\\', '/');
+ int slash = normalized.lastIndexOf('/');
+ return slash < 0 ? normalized : normalized.substring(slash + 1);
+ }
+
+ private static boolean isCredentialFileName(String fileName) {
+ String lower = fileName == null ? "" : fileName.trim().toLowerCase(Locale.ROOT);
+ if (lower.isEmpty()) {
+ return false;
+ }
+ if (FORBIDDEN_CREDENTIAL_NAMES.contains(lower) || lower.startsWith(".env.")) {
+ return true;
+ }
+ for (String suffix : FORBIDDEN_CREDENTIAL_SUFFIXES) {
+ if (lower.endsWith(suffix)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /** 拒绝分支统一清对象;清理失败只告警,不让业务错误被存储异常盖掉。 */
+ private void removeRejectedObject(String objectKey) {
+ try {
+ ossStorageService.removeWorkbenchClientObject(objectKey);
+ } catch (RuntimeException ex) {
+ log.warn("[workbench-client] 清理被拒安装包对象失败 objectKey={} err={}",
+ objectKey, ex.getMessage());
+ }
+ }
+
+ private void deleteTempQuietly(Path packageFile) {
+ if (packageFile == null) {
+ return;
+ }
+ try {
+ Files.deleteIfExists(packageFile);
+ } catch (IOException ex) {
+ log.warn("[workbench-client] 删除安装包临时文件失败 path={} err={}",
+ packageFile, ex.getMessage());
+ }
+ }
+
/**
* 按 id 批量删除记录;MinIO 对象仅在删除后无任何剩余记录引用时才清除。
* 最新包被删后,客户端下次检查自动回落到上一版(按上传时间取最新)。
diff --git a/backend-java/src/main/resources/db/V176__workbench_client_package_version_unique.sql b/backend-java/src/main/resources/db/V176__workbench_client_package_version_unique.sql
new file mode 100644
index 000000000..dae1fda64
--- /dev/null
+++ b/backend-java/src/main/resources/db/V176__workbench_client_package_version_unique.sql
@@ -0,0 +1,23 @@
+-- =============================================================
+-- 迁移 V176__workbench_client_package_version_unique
+-- 立账:ops 仓 docs/audit/CODE_REVIEW_REPORT.md CR-05(2026-10-26)
+--
+-- 1. 变更目的:给「数富AI工作台客户端包」的版本号加唯一约束。
+-- confirmPackage 原实现是 SELECT COUNT(version) 再 INSERT,两步之间无数据库
+-- 约束保护:两名管理员并发确认同一版本、不同 objectKey 时,两次 count 都读到 0,
+-- 最终落两行同 version、不同 sha256 的记录,客户端会拿到错误的完整性锚点。
+--
+-- 2. 口径:
+-- - 唯一键名 uk_workbench_client_version,列 version;
+-- - objectKey 已有 uk_workbench_client_object_key(V167),两把唯一键各守一条
+-- 并发路径:同对象幂等、同版本拒绝;
+-- - 线上只读核验(2026-10-26):当前 7 行、7 个不同 version,无重复,可安全加键。
+--
+-- 3. 影响表与数据量:biz_workbench_client_package 加一把唯一索引;表为 KB 级字典表。
+--
+-- 4. 回滚(如需):ALTER TABLE `biz_workbench_client_package`
+-- DROP INDEX `uk_workbench_client_version`;
+-- =============================================================
+
+ALTER TABLE `biz_workbench_client_package`
+ ADD UNIQUE KEY `uk_workbench_client_version` (`version`);
diff --git a/backend-java/src/main/resources/db/V177__keyword_usage_tables.sql b/backend-java/src/main/resources/db/V177__keyword_usage_tables.sql
new file mode 100644
index 000000000..2132a6d15
--- /dev/null
+++ b/backend-java/src/main/resources/db/V177__keyword_usage_tables.sql
@@ -0,0 +1,79 @@
+-- =============================================================
+-- 迁移 V177__keyword_usage_tables
+-- 立账:ops 仓 docs/audit/CODE_REVIEW_REPORT.md CR-18(2026-10-26)
+--
+-- 1. 变更目的:给「关键词使用记录」依赖的四张表补 Flyway DDL。
+-- keyword_usage / keyword_add_log / keyword_delete_log / keyword_share 在现网主库
+-- 早已存在(桌面 Tkinter 工具与 web 版共用),此前没有入库的建表脚本;新环境首次
+-- 打开管理后台会因表缺失直接 500。本迁移只服务新环境,线上四表已存在。
+--
+-- 2. 口径:
+-- - 一律 CREATE TABLE IF NOT EXISTS,线上重跑逐条 no-op;
+-- - 字段按 KeywordUsageAdminMapper.xml / KeywordShareMapper.xml 与
+-- KeywordUsageEntity / KeywordAddLogEntity / KeywordDeleteLogEntity /
+-- KeywordShareEntity 逐列核对,不臆造业务列;
+-- - keyword_share 与 keyword_usage 的 uk_comp_cw(company_id, country, keyword)
+-- 是既有 UPSERT(ON DUPLICATE KEY UPDATE)与删除/标记语义的依赖键,必须一并建;
+-- - keyword_delete_log 只留痕,不建唯一键(同一词可被反复添加/删除)。
+--
+-- 3. 影响表与数据量:新环境建 4 张空表;已有环境 4 条 no-op。
+--
+-- 4. 回滚(如需,按依赖顺序):
+-- DROP TABLE IF EXISTS `keyword_usage`;
+-- DROP TABLE IF EXISTS `keyword_add_log`;
+-- DROP TABLE IF EXISTS `keyword_delete_log`;
+-- DROP TABLE IF EXISTS `keyword_share`;
+-- =============================================================
+
+CREATE TABLE IF NOT EXISTS `keyword_share` (
+ `id` BIGINT NOT NULL AUTO_INCREMENT,
+ `country` VARCHAR(32) NOT NULL COMMENT '国家(英国/德国/法国/西班牙/意大利等)',
+ `keyword` VARCHAR(255) NOT NULL COMMENT '关键词',
+ `chinese` VARCHAR(255) DEFAULT NULL COMMENT '中文释义',
+ `ktype` VARCHAR(64) DEFAULT NULL COMMENT '关键词类型',
+ `source` VARCHAR(64) DEFAULT NULL COMMENT '来源',
+ `category` VARCHAR(128) DEFAULT NULL COMMENT '一级类目',
+ `sub_category` VARCHAR(128) DEFAULT NULL COMMENT '二级类目',
+ `category_l3` VARCHAR(128) DEFAULT NULL COMMENT '三级类目',
+ `category_l4` VARCHAR(128) DEFAULT NULL COMMENT '四级类目',
+ `user_name` VARCHAR(128) NOT NULL DEFAULT '' COMMENT '添加人',
+ `add_time` DATETIME DEFAULT NULL COMMENT '添加时间',
+ `company_id` BIGINT NOT NULL DEFAULT 1 COMMENT '公司隔离键',
+ PRIMARY KEY (`id`),
+ UNIQUE KEY `uk_comp_cw` (`company_id`, `country`, `keyword`),
+ KEY `idx_keyword_share_company_category` (`company_id`, `category`, `sub_category`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='五国关键词共享-词本体';
+
+CREATE TABLE IF NOT EXISTS `keyword_usage` (
+ `id` BIGINT NOT NULL AUTO_INCREMENT,
+ `country` VARCHAR(32) NOT NULL COMMENT '国家',
+ `keyword` VARCHAR(255) NOT NULL COMMENT '关键词',
+ `user_name` VARCHAR(128) NOT NULL DEFAULT '' COMMENT '使用者',
+ `used_time` DATETIME DEFAULT NULL COMMENT '最近使用时间',
+ `company_id` BIGINT NOT NULL DEFAULT 1 COMMENT '公司隔离键',
+ PRIMARY KEY (`id`),
+ UNIQUE KEY `uk_comp_cw` (`company_id`, `country`, `keyword`),
+ KEY `idx_keyword_usage_company_time` (`company_id`, `used_time`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='五国关键词共享-使用状态';
+
+CREATE TABLE IF NOT EXISTS `keyword_add_log` (
+ `id` BIGINT NOT NULL AUTO_INCREMENT,
+ `country` VARCHAR(32) NOT NULL COMMENT '国家',
+ `keyword` VARCHAR(255) NOT NULL COMMENT '关键词',
+ `user_name` VARCHAR(128) NOT NULL DEFAULT '' COMMENT '添加人',
+ `add_time` DATETIME DEFAULT NULL COMMENT '添加时间',
+ `company_id` BIGINT NOT NULL DEFAULT 1 COMMENT '公司隔离键',
+ PRIMARY KEY (`id`),
+ KEY `idx_keyword_add_log_company_time` (`company_id`, `add_time`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='五国关键词共享-添加留痕';
+
+CREATE TABLE IF NOT EXISTS `keyword_delete_log` (
+ `id` BIGINT NOT NULL AUTO_INCREMENT,
+ `country` VARCHAR(32) NOT NULL COMMENT '国家',
+ `keyword` VARCHAR(255) NOT NULL COMMENT '关键词',
+ `user_name` VARCHAR(128) NOT NULL DEFAULT '' COMMENT '删除人',
+ `delete_time` DATETIME DEFAULT NULL COMMENT '删除时间',
+ `company_id` BIGINT NOT NULL DEFAULT 1 COMMENT '公司隔离键',
+ PRIMARY KEY (`id`),
+ KEY `idx_keyword_delete_log_company_time` (`company_id`, `delete_time`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='五国关键词共享-删除留痕';
diff --git a/backend-java/src/test/java/com/nanri/aiimage/config/CatchSilenceRatchetTest.java b/backend-java/src/test/java/com/nanri/aiimage/config/CatchSilenceRatchetTest.java
index b7f8875e7..f34b183dd 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/config/CatchSilenceRatchetTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/config/CatchSilenceRatchetTest.java
@@ -49,8 +49,9 @@ class CatchSilenceRatchetTest {
// 10-18 外观专利失败兜底自吞抬 561 -> 562,逐处出处同下。
// 10-24 损耗监控三处带锚点的 fail-open 抬 562 -> 564,逐处出处见 STRICT_NOT_RETHROW 上方注释。
// 10-25 B15 join 无界收口抬 564 -> 569,逐处出处见 STRICT_NOT_RETHROW 上方注释。
+ // 10-26 第二轮 CR-Fix 2 抬 569 -> 573,逐处出处见 STRICT_NOT_RETHROW 上方注释(4 处必要 fail-open)。
static final int GIVEN_TOTAL = 1000;
- static final int GIVEN_NOT_RETHROW = 569;
+ static final int GIVEN_NOT_RETHROW = 573;
static final int GIVEN_LOG_ONLY = 249;
static final int GIVEN_EMPTY = 56;
@@ -120,8 +121,28 @@ class CatchSilenceRatchetTest {
* 逐行链路的缓存,缺结果的行会走单行回退,所以等待侧超时不需要炸掉整条任务。
*
* 同批实测 notRethrow 569、logOnly 176、empty 56;气味三格只按这三处实测值抬,形状未放宽。
+ *
+ *
10-26 抬 1015 -> 1024(第二轮 CR-Fix 2,共 9 处新增 catch,逐处记名):
+ *
+ * - {@code WorkbenchClientPackageService.confirmPackage} 一枚:{@code DuplicateKeyException}
+ * 并发冲突按 objectKey 幂等或转业务错误(RETHROW);
+ * - {@code WorkbenchClientPackageService.rejectCredentialFiles} 两枚:{@code BusinessException}
+ * 原样重抛、{@code IOException} 清对象后转业务错误(RETHROW);
+ * - {@code WorkbenchClientPackageService.removeRejectedObject} 一枚:{@code RuntimeException}
+ * 清理失败只 WARN,不让存储异常盖掉业务错误(LOG_ONLY);
+ * - {@code WorkbenchClientPackageService.deleteTempQuietly} 一枚:{@code IOException}
+ * 删临时文件失败只 WARN(LOG_ONLY);
+ * - {@code OssStorageService.downloadWorkbenchClientObjectToTempFile} 两枚:外层
+ * {@code Exception} 转 {@code storageFailure} 重抛(RETHROW),内层清理失败只 WARN(LOG_ONLY);
+ * - {@code CostGuardScheduler} 一枚:平台自费告警推送失败只 WARN 并保留基线待下轮重试
+ * (NOT_RETHROW,log+return);
+ * - {@code SimilarAsinLlmService} 一枚:{@code InterruptedException} 恢复中断位后上抛
+ * (RETHROW)。
+ *
+ * 9 处均为 CR-02/05/10/20 的必要出口,不是把已有异常改回吞掉;同批实测 total 1024、
+ * notRethrow 573、logOnly 179、empty 56。
*/
- static final int STRICT_TOTAL = 1015;
+ static final int STRICT_TOTAL = 1024;
/**
* 重抛型 catch 的**下限**(不是上限):本轮把两处吞异常改成重抛之后实测 388。
* 这一格只能涨不能跌——它是"异常会往外走"的总量,把它钉成"只许减"就等于拦着别人修吞异常。
@@ -207,8 +228,14 @@ class CatchSilenceRatchetTest {
* {@code AppearancePatentLlmClient.runBatches} 两枚(超时/执行失败、中断各收口成该批失败),
* {@code SimilarAsinLlmService} 类目与合规两个 prepass 各两枚(超时/执行失败只 WARN,
* 中断复位中断位后退出等待)。两处预计算的缺行都会走单行回退,不是把已有出口改回吞掉。
+ * 10-26 抬 569 -> 573(第二轮 CR-Fix 2,4 处新增不重抛,逐处记名):
+ * {@code WorkbenchClientPackageService.removeRejectedObject}(清理失败只 WARN,不让存储异常
+ * 盖掉业务错误)、{@code deleteTempQuietly}(删临时文件失败只 WARN)、
+ * {@code OssStorageService.downloadWorkbenchClientObjectToTempFile} 内层清理(同上)、
+ * {@code CostGuardScheduler}(平台自费告警推送失败 log+return,保留基线待下轮重试)。
+ * 四处的误差方向都是「不让清理/告警失败掩盖主错误」,不是把异常静默吞掉。
*/
- static final int STRICT_NOT_RETHROW = 569;
+ static final int STRICT_NOT_RETHROW = 573;
/**
* 10-17 抬 172 -> 173,出处就是上面点名过的 {@code TaskHeartbeatLivenessService.stamp()}:
* 块体只有「取到 key 名 + log.warn」一句,写心跳证据失败时既不重试也不抛出——
@@ -221,8 +248,11 @@ class CatchSilenceRatchetTest {
* 两个超时出口之一(两处形状相同,其中一处按块内语句判定落进本格,另一处因复位中断位
* 多一条语句只进 NOT_RETHROW)。块体只有一句带 {@code [similar-asin][llm]} 锚点的 WARN,
* 缺结果的行走单行回退,不是无声吞掉。
+ * 10-26 抬 176 -> 179(第二轮 CR-Fix 2,3 处新增 log-only):{@code WorkbenchClientPackageService}
+ * 的 removeRejectedObject/deleteTempQuietly 与 {@code OssStorageService} 的临时文件清理内层,
+ * 三处都只 WARN 且带 path/objectKey 锚点;主错误由外层重抛,清理失败不得盖掉它。
*/
- static final int STRICT_LOG_ONLY = 176; // 严格口径:块内每条顶层语句都是 log 调用才算
+ static final int STRICT_LOG_ONLY = 179; // 严格口径:块内每条顶层语句都是 log 调用才算
static final int STRICT_EMPTY = 56;
/**
diff --git a/backend-java/src/test/java/com/nanri/aiimage/config/KeywordUsageTablesMigrationV177Test.java b/backend-java/src/test/java/com/nanri/aiimage/config/KeywordUsageTablesMigrationV177Test.java
new file mode 100644
index 000000000..52883c92c
--- /dev/null
+++ b/backend-java/src/test/java/com/nanri/aiimage/config/KeywordUsageTablesMigrationV177Test.java
@@ -0,0 +1,43 @@
+package com.nanri.aiimage.config;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/** CR-18:V177 给关键词使用记录四张表补新环境可用的 Flyway DDL。 */
+class KeywordUsageTablesMigrationV177Test {
+
+ private static final Path DB_DIR =
+ Path.of(System.getProperty("user.dir"), "src/main/resources/db");
+
+ private static Path migration() throws IOException {
+ try (Stream files = Files.list(DB_DIR)) {
+ List hits = files
+ .filter(p -> p.getFileName().toString().startsWith("V177__"))
+ .toList();
+ assertEquals(1, hits.size(), "V177 必须恰好一个迁移文件");
+ return hits.get(0);
+ }
+ }
+
+ @Test
+ void createsAllFourKeywordTablesIdempotently() throws IOException {
+ String sql = Files.readString(migration());
+ assertTrue(sql.contains("迁移 V177__keyword_usage_tables"), "头注释版本必须与文件名一致");
+ for (String table : List.of("keyword_usage", "keyword_add_log", "keyword_delete_log", "keyword_share")) {
+ assertTrue(sql.contains("CREATE TABLE IF NOT EXISTS `" + table + "`"),
+ "缺少新环境建表(必须 IF NOT EXISTS,线上已存在): " + table);
+ }
+ assertTrue(sql.contains("UNIQUE KEY `uk_comp_cw` (`company_id`, `country`, `keyword`)"),
+ "keyword_share/keyword_usage 的 UPSERT 依赖 (company_id,country,keyword) 唯一键");
+ assertTrue(sql.contains("`company_id` BIGINT NOT NULL DEFAULT 1"),
+ "四张表都必须带公司隔离键");
+ }
+}
diff --git a/backend-java/src/test/java/com/nanri/aiimage/config/TaskResultFileJobWorkerLogAuditTest.java b/backend-java/src/test/java/com/nanri/aiimage/config/TaskResultFileJobWorkerLogAuditTest.java
index 5678d3fdc..a38bafc67 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/config/TaskResultFileJobWorkerLogAuditTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/config/TaskResultFileJobWorkerLogAuditTest.java
@@ -103,7 +103,8 @@ class TaskResultFileJobWorkerLogAuditTest {
// 2026-10-24 B28:父任务终态后不再领取/执行/续期,三条出口各有一个阶段字面量。
List allowed = List.of("SKIP_OWNER", "REQUEUE", "WAIT_LLM", "DEFER", "SUCCESS",
"SUCCESS_LOST", "ORPHAN", "FAILED", "FINALIZE", "HEARTBEAT", "FALLBACK",
- "TERMINAL_SKIP", "TERMINAL_AFTER_LOCK", "TERMINAL_STOP_RENEW");
+ "TERMINAL_SKIP", "TERMINAL_AFTER_LOCK", "TERMINAL_STOP_RENEW",
+ "TERMINAL_KEEP_SUCCESS", "TERMINAL_AFTER_EXECUTION");
for (String l : perJob) {
if (l.contains("stage=")) {
int idx = l.indexOf("stage=");
diff --git a/backend-java/src/test/java/com/nanri/aiimage/config/WorkbenchClientPackageVersionUniqueMigrationV176Test.java b/backend-java/src/test/java/com/nanri/aiimage/config/WorkbenchClientPackageVersionUniqueMigrationV176Test.java
new file mode 100644
index 000000000..1085d3318
--- /dev/null
+++ b/backend-java/src/test/java/com/nanri/aiimage/config/WorkbenchClientPackageVersionUniqueMigrationV176Test.java
@@ -0,0 +1,40 @@
+package com.nanri.aiimage.config;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/** CR-05:V176 用数据库唯一键兜住「同 version 不同 objectKey」的并发登记。 */
+class WorkbenchClientPackageVersionUniqueMigrationV176Test {
+
+ private static final Path DB_DIR =
+ Path.of(System.getProperty("user.dir"), "src/main/resources/db");
+
+ private static Path migration() throws IOException {
+ try (Stream files = Files.list(DB_DIR)) {
+ List hits = files
+ .filter(p -> p.getFileName().toString().startsWith("V176__"))
+ .toList();
+ assertEquals(1, hits.size(), "V176 必须恰好一个迁移文件");
+ return hits.get(0);
+ }
+ }
+
+ @Test
+ void addsUniqueKeyOnVersionWithoutTouchingAppliedMigrations() throws IOException {
+ String sql = Files.readString(migration());
+ assertTrue(sql.contains("迁移 V176__workbench_client_package_version_unique"),
+ "头注释版本必须与文件名一致");
+ assertTrue(sql.contains("ALTER TABLE `biz_workbench_client_package`"),
+ "只在客户端包表上加键");
+ assertTrue(sql.contains("ADD UNIQUE KEY `uk_workbench_client_version` (`version`)"),
+ "同版本并发登记必须由数据库唯一键兜底");
+ }
+}
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/auth/service/AuthServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/auth/service/AuthServiceTest.java
index a9669714e..5c276db56 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/auth/service/AuthServiceTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/auth/service/AuthServiceTest.java
@@ -106,6 +106,30 @@ class AuthServiceTest {
// ---------- check_login:被顶下线必须拦截且不续期 ----------
+ @Test
+ void loginSignsTokenWithSessionEpochReadBackFromDatabase() {
+ // CR-07:并发登录时库里的世代可能已被另一路推到 N+2;内存 +1 会签出 stale token,
+ // 登录成功后第一次请求立刻 401。令牌必须用自增后回读到的库值。
+ Fixture f = fixture(true);
+ LoginUserEntity user = f.user("devA");
+ user.setSessionEpoch(0L);
+ LoginUserEntity refreshed = f.user("devA");
+ refreshed.setSessionEpoch(41L);
+ when(f.loginUserMapper.selectOne(any())).thenReturn(user);
+ when(f.loginUserMapper.selectById(7L)).thenReturn(refreshed);
+ when(f.passwordEncoder.matches("pwd", "hash")).thenReturn(true);
+ when(f.jwtService.issue(eq(7L), anyString(), anyString(), anyLong())).thenReturn("jwt-token");
+
+ LoginRequest request = new LoginRequest();
+ request.setUsername("u7");
+ request.setPassword("pwd");
+ request.setDeviceId("devB");
+
+ f.service.login(request);
+
+ verify(f.jwtService).issue(7L, "u7", "devB", 41L);
+ }
+
@Test
void checkLoginRejectsSupersededDeviceWithoutRenewal() {
Fixture f = fixture(true);
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/brandgating/controller/BrandGatingControllerTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/brandgating/controller/BrandGatingControllerTest.java
new file mode 100644
index 000000000..605f2306e
--- /dev/null
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/brandgating/controller/BrandGatingControllerTest.java
@@ -0,0 +1,109 @@
+package com.nanri.aiimage.modules.brandgating.controller;
+
+import com.nanri.aiimage.common.exception.BusinessException;
+import com.nanri.aiimage.common.model.entity.AdminUserEntity;
+import com.nanri.aiimage.common.security.AdminAuthSupport;
+import com.nanri.aiimage.modules.brandgating.model.dto.BrandGatingAddRequest;
+import com.nanri.aiimage.modules.brandgating.model.dto.BrandGatingImportRequest;
+import com.nanri.aiimage.modules.brandgating.model.dto.BrandGatingStatusRequest;
+import com.nanri.aiimage.modules.brandgating.model.vo.BrandGatingPageVo;
+import com.nanri.aiimage.modules.brandgating.service.BrandGatingService;
+import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
+import jakarta.servlet.http.HttpServletRequest;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * CR-11:{@code biz_brand_gating} 全平台共享,写操作只允许平台超级管理员;
+ * 公司管理员(即使持有 admin_brand_gating 菜单)只能读。
+ */
+@ExtendWith(MockitoExtension.class)
+class BrandGatingControllerTest {
+
+ @Mock private BrandGatingService brandGatingService;
+ @Mock private AdminAuthSupport adminAuthSupport;
+ @Mock private PermissionMenuService permissionMenuService;
+ @Mock private HttpServletRequest request;
+
+ private BrandGatingController controller;
+ private AdminUserEntity companyAdmin;
+ private AdminUserEntity platformSuperAdmin;
+
+ @BeforeEach
+ void setUp() {
+ controller = new BrandGatingController(brandGatingService, adminAuthSupport, permissionMenuService);
+ companyAdmin = user(51L, "company-admin", "company_super_admin");
+ platformSuperAdmin = user(1L, "root", "super_admin");
+ when(adminAuthSupport.requireUser(request)).thenReturn(companyAdmin);
+ }
+
+ @Test
+ @DisplayName("公司管理员写操作全部 403:新增/删除/启停/批量导入都不触碰业务层")
+ void companyAdminCannotWrite() {
+ when(adminAuthSupport.currentRole(companyAdmin)).thenReturn("company_super_admin");
+ BrandGatingStatusRequest status = new BrandGatingStatusRequest();
+ status.setStatus(1);
+
+ assertForbidden(() -> controller.add(request, new BrandGatingAddRequest()));
+ assertForbidden(() -> controller.delete(request, 9L));
+ assertForbidden(() -> controller.updateStatus(request, 9L, status));
+ assertForbidden(() -> controller.importRows(request, new BrandGatingImportRequest()));
+
+ verify(brandGatingService, never()).add(any());
+ verify(brandGatingService, never()).delete(any());
+ verify(brandGatingService, never()).updateStatus(any(), any());
+ verify(brandGatingService, never()).importRows(any());
+ }
+
+ @Test
+ @DisplayName("只读查询不受影响:公司管理员有 admin_brand_gating 菜单即可分页")
+ void companyAdminStillReads() {
+ when(brandGatingService.page(any(), any(), any(), any(), any(), any(), any()))
+ .thenReturn(new BrandGatingPageVo());
+
+ controller.page(request, null, null, null, null, null, 1L, 10L);
+
+ verify(permissionMenuService).requireConsolePageAccess(
+ eq(companyAdmin), any(), eq("admin_brand_gating"));
+ verify(brandGatingService).page(any(), any(), any(), any(), any(), any(), any());
+ }
+
+ @Test
+ @DisplayName("平台超管写操作放行")
+ void superAdminCanWrite() {
+ when(adminAuthSupport.requireUser(request)).thenReturn(platformSuperAdmin);
+ when(adminAuthSupport.currentRole(platformSuperAdmin)).thenReturn("super_admin");
+ BrandGatingAddRequest body = new BrandGatingAddRequest();
+
+ controller.add(request, body);
+
+ verify(brandGatingService).add(body);
+ }
+
+ private static void assertForbidden(org.junit.jupiter.api.function.Executable action) {
+ assertThatThrownBy(action::execute)
+ .isInstanceOf(BusinessException.class)
+ .satisfies(ex -> assertThat(((BusinessException) ex).getCode()).isEqualTo(403));
+ }
+
+ private static AdminUserEntity user(long id, String username, String role) {
+ AdminUserEntity user = new AdminUserEntity();
+ user.setId(id);
+ user.setUsername(username);
+ user.setRole(role);
+ user.setIsAdmin(1);
+ return user;
+ }
+}
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/brandgating/service/BrandGatingServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/brandgating/service/BrandGatingServiceTest.java
index cf300c555..592223615 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/brandgating/service/BrandGatingServiceTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/brandgating/service/BrandGatingServiceTest.java
@@ -464,16 +464,20 @@ class BrandGatingServiceTest {
}
@Test
- @DisplayName("控制器契约:独立菜单用 admin_brand_gating 权限键、逐端点 requireUser + requireConsolePageAccess 把门")
- void controllerGatesEveryEndpointWithPermissionKey() throws Exception {
+ @DisplayName("控制器契约:读用 admin_brand_gating 菜单权限,写再收窄到平台超管(CR-11)")
+ void controllerGatesReadsWithMenuAndWritesWithPlatformSuperAdmin() throws Exception {
String source = Files.readString(Path.of(
"src/main/java/com/nanri/aiimage/modules/brandgating/controller/BrandGatingController.java"),
StandardCharsets.UTF_8);
assertThat(source).contains("PERMISSION_KEY = \"admin_brand_gating\"");
assertThat(source).contains("adminAuthSupport.requireUser(request)");
assertThat(source).contains("requireConsolePageAccess(operator, DENIAL_MESSAGE, PERMISSION_KEY)");
- // 6 个端点方法都必须先过把门助手
- long gated = source.split("requireBrandGatingAccess\\(request\\);", -1).length - 1;
- assertThat(gated).isEqualTo(6);
+ // 2 个只读端点(page/stats)继续走菜单权限
+ long readGated = source.split("requireBrandGatingAccess\\(request\\);", -1).length - 1;
+ assertThat(readGated).isEqualTo(2);
+ // 4 个写端点(add/delete/status/import)叠加平台超管闸门
+ long writeGated = source.split("requirePlatformSuperAdmin\\(request\\);", -1).length - 1;
+ assertThat(writeGated).isEqualTo(4);
+ assertThat(source).contains("DeviceSessionPolicy.isSuper(adminAuthSupport.currentRole(operator))");
}
}
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/keywordusage/service/KeywordUsageAdminServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/keywordusage/service/KeywordUsageAdminServiceTest.java
index 735e9eb5d..df7076a27 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/keywordusage/service/KeywordUsageAdminServiceTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/keywordusage/service/KeywordUsageAdminServiceTest.java
@@ -81,6 +81,37 @@ class KeywordUsageAdminServiceTest {
verify(keywordUsageAdminMapper, never()).countUsageRows(any());
}
+ @Test
+ @DisplayName("CR-18:page=Long.MAX_VALUE 必须钳到安全上限,offset 不得溢出为负")
+ void hugePageIsClampedToSafeOffset() {
+ when(keywordUsageAdminMapper.countUsageRows(any())).thenReturn(0L);
+ when(keywordUsageAdminMapper.countCopy(any())).thenReturn(0L);
+ when(keywordUsageAdminMapper.countCopyExisting(any())).thenReturn(0L);
+ when(keywordUsageAdminMapper.countAdd(any())).thenReturn(0L);
+ when(keywordUsageAdminMapper.selectUsageRows(any())).thenReturn(List.of());
+
+ service.usage(1L, null, null, null, null, Long.MAX_VALUE, 15L);
+
+ ArgumentCaptor captor = ArgumentCaptor.forClass(KeywordUsageFilterQuery.class);
+ verify(keywordUsageAdminMapper).selectUsageRows(captor.capture());
+ assertThat(captor.getValue().getOffset()).isEqualTo(149_985L)
+ .isNotNegative();
+ assertThat(captor.getValue().getLimit()).isEqualTo(15L);
+ }
+
+ @Test
+ @DisplayName("CR-18:删除记录页同样钳制 page,offset 不溢出")
+ void hugePageIsClampedForDeletes() {
+ when(keywordUsageAdminMapper.countDeletes(any())).thenReturn(0L);
+ when(keywordUsageAdminMapper.selectDeleteRows(any())).thenReturn(List.of());
+
+ service.deletes(1L, null, null, null, Long.MAX_VALUE, 100L);
+
+ ArgumentCaptor captor = ArgumentCaptor.forClass(KeywordUsageFilterQuery.class);
+ verify(keywordUsageAdminMapper).selectDeleteRows(captor.capture());
+ assertThat(captor.getValue().getOffset()).isEqualTo(999_900L).isNotNegative();
+ }
+
@Test
@DisplayName("分页参数:page<1 归一为 1,page_size 上限 100")
void pageParamsAreClamped() {
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlTaskServiceOwnerTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlTaskServiceOwnerTest.java
index 056c4793d..456433915 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlTaskServiceOwnerTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlTaskServiceOwnerTest.java
@@ -91,6 +91,34 @@ class ShopDataCrawlTaskServiceOwnerTest {
verify(ossStorageService).deleteObject("result/shared.xlsx");
}
+ @Test
+ void resultFileJobFailureNeverRewritesTerminalParentTask() {
+ // CR-09:终态父任务可能遗留 PENDING/RUNNING 结果作业;失败回调不得把
+ // SUCCESS/CANCELLED/FAILED 无条件改写成 FAILED。
+ com.nanri.aiimage.modules.task.service.TaskDistributedLockService.LockHandle lock =
+ org.mockito.Mockito.mock(com.nanri.aiimage.modules.task.service.TaskDistributedLockService.LockHandle.class);
+ when(taskDistributedLockService.acquire("SHOP_DATA_CRAWL", 21L)).thenReturn(lock);
+ FileTaskEntity task = new FileTaskEntity();
+ task.setId(21L);
+ task.setModuleType("SHOP_DATA_CRAWL");
+ when(fileTaskMapper.selectById(21L)).thenReturn(task);
+ com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity job =
+ new com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity();
+ job.setId(901L);
+ job.setTaskId(21L);
+ job.setModuleType("SHOP_DATA_CRAWL");
+
+ for (String terminal : java.util.List.of("SUCCESS", "CANCELLED", "FAILED")) {
+ task.setStatus(terminal);
+ service.handleResultFileJobFailure(job, "retry exhausted");
+
+ assertEquals(terminal, task.getStatus(), "终态父任务不得被失败回调改写: " + terminal);
+ }
+
+ verify(fileTaskMapper, never()).updateById(any(FileTaskEntity.class));
+ verify(fileResultMapper, never()).updateById(any(com.nanri.aiimage.modules.task.model.entity.FileResultEntity.class));
+ }
+
private FileTaskEntity task(String owner) {
FileTaskEntity task = new FileTaskEntity();
task.setId(1L);
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmServiceTest.java
index 758c95686..0bc7b4da3 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmServiceTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmServiceTest.java
@@ -271,6 +271,45 @@ class SimilarAsinLlmServiceTest {
assertNull(result.get(0).getPuzzleImg1());
}
+ @Test
+ void inspectRowsRestoresInterruptFlagWhenAwaitIsInterrupted() throws Exception {
+ // CR-20:等待被中断时不能落入 catch (Exception) 吞掉;必须恢复中断标志并向上抛。
+ java.util.concurrent.CountDownLatch entered = new java.util.concurrent.CountDownLatch(1);
+ java.util.concurrent.CountDownLatch release = new java.util.concurrent.CountDownLatch(1);
+ SimilarAsinLlmClient client = mock(SimilarAsinLlmClient.class);
+ when(client.hasApiKey("k")).thenReturn(true);
+ when(client.invokeChat(anyString(), anyString(), anyString(), anyString())).thenAnswer(invocation -> {
+ entered.countDown();
+ release.await(5, java.util.concurrent.TimeUnit.SECONDS);
+ return "{\"first\":\"类目A\",\"second\":\"类目B\"}";
+ });
+ SimilarAsinLlmService service = service(client);
+ SimilarAsinResultRowDto row = rowOf("B01", "A");
+
+ java.util.concurrent.atomic.AtomicReference failure =
+ new java.util.concurrent.atomic.AtomicReference<>();
+ Thread caller = new Thread(() -> {
+ try {
+ service.inspectRows(List.of(row), "", "k", false, true);
+ } catch (Throwable ex) {
+ failure.set(ex);
+ }
+ }, "interrupt-await-test");
+ try {
+ caller.start();
+ assertTrue(entered.await(5, java.util.concurrent.TimeUnit.SECONDS),
+ "worker 必须先真正阻塞在等待上");
+ caller.interrupt();
+ caller.join(5_000L);
+ assertFalse(caller.isAlive(), "中断后等待必须立刻返回,不能继续等 worker");
+ assertTrue(failure.get() instanceof IllegalStateException,
+ "中断必须向上抛出,不能被 catch(Exception) 吞成行级失败: " + failure.get());
+ assertTrue(caller.isInterrupted(), "中断标志必须恢复(Thread.currentThread().interrupt())");
+ } finally {
+ release.countDown();
+ }
+ }
+
@Test
void imageCompareStopsOnStockAndFillsFields() {
// 第 1 次 chat:合并类目调用一次给出一级+二级名称(Java 按名回查取真实 ID);第 2 次:合规检查。
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorkerStuckScanTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorkerStuckScanTest.java
index ee564588f..651ca0365 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorkerStuckScanTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskResultFileJobWorkerStuckScanTest.java
@@ -353,9 +353,9 @@ class TaskResultFileJobWorkerStuckScanTest {
}
@Test
- void terminalParentHeartbeatStopsTouchingAndFailsJob() throws Exception {
- // 父任务在 worker 执行中变终态:心跳不得再 touchRunning(否则 stuck 扫描永远看不到),
- // 并主动把 job 收口为 FAILED;终态回调留给兜底扫描出部分结果,失败任务仍可下载。
+ void terminalParentHeartbeatStopsTouchingButLeavesTerminalVerdictToExecutionThread() throws Exception {
+ // CR-08:父任务在 worker 执行中变终态:心跳只停续期、停 touchRunning,
+ // 不再抢先把仍在执行的 job 翻成 FAILED——否则执行线程的 markSuccess 会被丢弃。
TaskResultFileJobWorker worker = buildWorker();
setLong(worker, "heartbeatIntervalMillis", 10L);
TaskFileJobEntity job = new TaskFileJobEntity();
@@ -363,23 +363,158 @@ class TaskResultFileJobWorkerStuckScanTest {
job.setTaskId(15L);
job.setModuleType("SIMILAR_ASIN");
job.setStatus("RUNNING");
+ TaskDistributedLockService.LockHandle lock = mock(TaskDistributedLockService.LockHandle.class);
+ Field handlesField = TaskResultFileJobWorker.class.getDeclaredField("activeLockHandles");
+ handlesField.setAccessible(true);
+ @SuppressWarnings("unchecked")
+ java.util.Map handles =
+ (java.util.Map) handlesField.get(worker);
+ handles.put(77L, lock);
when(taskFileJobService.isOwningTaskTerminal(15L)).thenReturn(true);
java.lang.reflect.Method method = TaskResultFileJobWorker.class
- .getDeclaredMethod("startJobHeartbeat", TaskFileJobEntity.class);
+ .getDeclaredMethod("startJobHeartbeat", TaskFileJobEntity.class,
+ java.util.concurrent.atomic.AtomicBoolean.class);
method.setAccessible(true);
java.util.concurrent.ScheduledFuture> future =
- (java.util.concurrent.ScheduledFuture>) method.invoke(worker, job);
+ (java.util.concurrent.ScheduledFuture>) method.invoke(worker, job,
+ new java.util.concurrent.atomic.AtomicBoolean(false));
try {
// heartbeat 间隔下限 1000ms,首轮在 1s 后才跑;给足调度余量
- verify(taskFileJobService, timeout(3000))
- .markFailedPermanentAwaitingFallback(eq(job), contains("父任务已终态"));
+ verify(lock, timeout(3000)).stopRenewal("parent-task-terminal", false);
verify(taskFileJobService, after(150).never()).touchRunning(77L);
+ verify(taskFileJobService, never())
+ .markFailedPermanentAwaitingFallback(any(), anyString());
} finally {
future.cancel(true);
}
}
+ @Test
+ void terminalVerdictAfterExecutionKeepsSuccessWrittenByTheExecutionThread() throws Exception {
+ // 竞态的另一半:心跳观察到终态时执行线程仍可能成功落库;退出后的收口必须保留 SUCCESS。
+ TaskResultFileJobWorker worker = buildWorker();
+ TaskFileJobEntity job = new TaskFileJobEntity();
+ job.setId(78L);
+ job.setTaskId(16L);
+ job.setModuleType("SIMILAR_ASIN");
+ TaskFileJobEntity success = new TaskFileJobEntity();
+ success.setId(78L);
+ success.setTaskId(16L);
+ success.setModuleType("SIMILAR_ASIN");
+ success.setStatus("SUCCESS");
+ when(taskFileJobService.findById(78L)).thenReturn(success);
+
+ worker.finishAfterExecution(job, new java.util.concurrent.atomic.AtomicBoolean(true));
+
+ verify(taskFileJobService, never()).markFailedPermanentAwaitingFallback(any(), anyString());
+ }
+
+ @Test
+ void terminalVerdictAfterExecutionFailsJobWhenExecutionDidNotSucceed() throws Exception {
+ TaskResultFileJobWorker worker = buildWorker();
+ TaskFileJobEntity job = new TaskFileJobEntity();
+ job.setId(79L);
+ job.setTaskId(17L);
+ job.setModuleType("SIMILAR_ASIN");
+ TaskFileJobEntity running = new TaskFileJobEntity();
+ running.setId(79L);
+ running.setTaskId(17L);
+ running.setStatus("RUNNING");
+ when(taskFileJobService.findById(79L)).thenReturn(running);
+
+ worker.finishAfterExecution(job, new java.util.concurrent.atomic.AtomicBoolean(true));
+
+ verify(taskFileJobService).markFailedPermanentAwaitingFallback(job, "父任务已终态,结果作业不再执行");
+ }
+
+ /**
+ * 真实竞态:执行线程还在跑时心跳发现父任务终态,随后执行线程成功落库。
+ * 心跳不得抢翻 FAILED,退出后的收口必须保留 SUCCESS。
+ */
+ @Test
+ void heartbeatTerminalRaceDoesNotDiscardExecutionThreadSuccess() throws Exception {
+ java.util.concurrent.CountDownLatch entered = new java.util.concurrent.CountDownLatch(1);
+ java.util.concurrent.CountDownLatch release = new java.util.concurrent.CountDownLatch(1);
+ java.util.concurrent.atomic.AtomicBoolean terminal = new java.util.concurrent.atomic.AtomicBoolean(false);
+ ResultFileJobHandler handler = new ResultFileJobHandler() {
+ @Override
+ public String moduleType() {
+ return "RACE_TEST";
+ }
+
+ @Override
+ public boolean process(TaskFileJobEntity job) {
+ entered.countDown();
+ try {
+ release.await(5, java.util.concurrent.TimeUnit.SECONDS);
+ } catch (InterruptedException ex) {
+ Thread.currentThread().interrupt();
+ return false;
+ }
+ return true;
+ }
+ };
+ ResultFileJobHandlerRegistry registry = new ResultFileJobHandlerRegistry(List.of(handler));
+ TaskResultFileJobWorker worker = new TaskResultFileJobWorker(
+ taskFileJobService, taskDistributedLockService, mock(FileResultMapper.class),
+ mock(TaskFileJobLocalDispatcher.class), instanceMetadata, registry);
+ setLong(worker, "heartbeatIntervalMillis", 10L);
+
+ TaskFileJobEntity job = new TaskFileJobEntity();
+ job.setId(80L);
+ job.setTaskId(18L);
+ job.setModuleType("RACE_TEST");
+ job.setStatus("RUNNING");
+ TaskFileJobEntity claim = new TaskFileJobEntity();
+ claim.setId(80L);
+ claim.setTaskId(18L);
+ claim.setModuleType("RACE_TEST");
+ claim.setStatus("RUNNING");
+ claim.setUpdatedAt(LocalDateTime.now());
+ TaskFileJobEntity success = new TaskFileJobEntity();
+ success.setId(80L);
+ success.setTaskId(18L);
+ success.setModuleType("RACE_TEST");
+ success.setStatus("SUCCESS");
+ TaskDistributedLockService.LockHandle lock = mock(TaskDistributedLockService.LockHandle.class);
+ when(taskFileJobService.isOwningTaskTerminal(18L)).thenAnswer(invocation -> terminal.get());
+ when(taskFileJobService.activateRunningClaim(claim)).thenReturn(true);
+ when(taskDistributedLockService.acquire("RACE_TEST", 18L,
+ TaskDistributedLockService.DEFAULT_WAIT_MILLIS)).thenReturn(lock);
+ when(taskFileJobService.findById(80L))
+ .thenReturn(job, job, success);
+ when(taskFileJobService.markSuccess(job, null)).thenReturn(true);
+
+ java.lang.reflect.Method method = TaskResultFileJobWorker.class.getDeclaredMethod(
+ "processClaimedWithHeartbeat", TaskFileJobEntity.class, TaskFileJobEntity.class);
+ method.setAccessible(true);
+ java.util.concurrent.ExecutorService runner = java.util.concurrent.Executors.newSingleThreadExecutor();
+ try {
+ java.util.concurrent.Future> run = runner.submit(() -> {
+ try {
+ method.invoke(worker, job, claim);
+ } catch (Exception ex) {
+ throw new IllegalStateException(ex);
+ }
+ });
+ assertTrue(entered.await(5, java.util.concurrent.TimeUnit.SECONDS),
+ "执行线程必须已进入 handler");
+ terminal.set(true);
+ // heartbeat 间隔下限 1000ms;留足一轮调度余量,让心跳先看到终态
+ Thread.sleep(1500L);
+ verify(taskFileJobService, never()).markFailedPermanentAwaitingFallback(any(), anyString());
+ release.countDown();
+ run.get(5, java.util.concurrent.TimeUnit.SECONDS);
+
+ verify(taskFileJobService).markSuccess(job, null);
+ verify(taskFileJobService, never()).markFailedPermanentAwaitingFallback(any(), anyString());
+ } finally {
+ release.countDown();
+ runner.shutdownNow();
+ }
+ }
+
/**
* 终态兜底出表只在归属实例做:非归属实例若抢先 markFailureFinalized,归属机的
* fallbackAssembleOnFailure 就永远跑不到,失败任务的结果文件也就永远不生成。
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/usersecret/service/CostGuardSchedulerTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/usersecret/service/CostGuardSchedulerTest.java
index 6b160ce58..b6abb8a35 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/usersecret/service/CostGuardSchedulerTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/usersecret/service/CostGuardSchedulerTest.java
@@ -126,6 +126,48 @@ class CostGuardSchedulerTest {
anyString(), contains("平台自费"), anyString(), isNull());
}
+ @Test
+ void platformAlertWithoutAnyAdminPersistedDoesNotAdvanceBaselineAndRetries() {
+ // CR-10:推送返回 0(没有管理员落库)时基线不得推进,否则下一轮 crossed 不再成立、告警永久丢失。
+ when(usageMapper.sumByUserAndModule(any(LocalDate.class)))
+ .thenReturn(List.of(row(0L, "proxy", 2_500, 0)));
+ when(notificationDispatchService.pushToAdmins(
+ eq(NotificationService.SCENE_COST_GUARD), eq(NotificationService.LEVEL_WARNING),
+ anyString(), contains("平台自费"), anyString(), isNull()))
+ .thenReturn(0, 1);
+
+ scheduler.runOnce();
+ assertThat(baselineStore.get(0L)).isNull();
+
+ scheduler.runOnce();
+ assertThat(baselineStore.get(0L).proxy).isEqualTo(2_500L);
+
+ scheduler.runOnce();
+ verify(notificationDispatchService, org.mockito.Mockito.times(2)).pushToAdmins(
+ eq(NotificationService.SCENE_COST_GUARD), eq(NotificationService.LEVEL_WARNING),
+ anyString(), contains("平台自费"), anyString(), isNull());
+ }
+
+ @Test
+ void platformAlertPushExceptionDoesNotAdvanceBaselineAndRetries() {
+ when(usageMapper.sumByUserAndModule(any(LocalDate.class)))
+ .thenReturn(List.of(row(0L, "proxy", 2_500, 0)));
+ when(notificationDispatchService.pushToAdmins(
+ eq(NotificationService.SCENE_COST_GUARD), eq(NotificationService.LEVEL_WARNING),
+ anyString(), contains("平台自费"), anyString(), isNull()))
+ .thenThrow(new IllegalStateException("redis down"))
+ .thenReturn(1);
+
+ scheduler.runOnce();
+ assertThat(baselineStore.get(0L)).isNull();
+
+ scheduler.runOnce();
+ assertThat(baselineStore.get(0L).proxy).isEqualTo(2_500L);
+ verify(notificationDispatchService, org.mockito.Mockito.times(2)).pushToAdmins(
+ eq(NotificationService.SCENE_COST_GUARD), eq(NotificationService.LEVEL_WARNING),
+ anyString(), contains("平台自费"), anyString(), isNull());
+ }
+
@Test
void llmCallsWindowJumpPauses() {
when(usageMapper.sumByUserAndModule(any(LocalDate.class)))
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/workbenchclient/service/WorkbenchClientPackageServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/workbenchclient/service/WorkbenchClientPackageServiceTest.java
index 3ca90015f..fc4396386 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/workbenchclient/service/WorkbenchClientPackageServiceTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/workbenchclient/service/WorkbenchClientPackageServiceTest.java
@@ -1,20 +1,42 @@
package com.nanri.aiimage.modules.workbenchclient.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.conditions.AbstractWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.modules.file.service.oss.OssStorageService;
import com.nanri.aiimage.modules.workbenchclient.mapper.WorkbenchClientPackageMapper;
import com.nanri.aiimage.modules.workbenchclient.model.entity.WorkbenchClientPackageEntity;
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.read.ListAppender;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.slf4j.LoggerFactory;
+import org.springframework.dao.DuplicateKeyException;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -40,10 +62,33 @@ class WorkbenchClientPackageServiceTest {
private final WorkbenchClientPackageMapper packageMapper = mock(WorkbenchClientPackageMapper.class);
private final OssStorageService ossStorageService = mock(OssStorageService.class);
+ @TempDir
+ Path tempDir;
+
private WorkbenchClientPackageService service() {
return new WorkbenchClientPackageService(packageMapper, ossStorageService);
}
+ /** 每次调用返回一个新的合法 zip:confirm 扫描后会把临时文件删掉,不能复用同一个路径。 */
+ private void stubCleanZip() {
+ when(ossStorageService.downloadWorkbenchClientObjectToTempFile(anyString()))
+ .thenAnswer(invocation -> zip("ShuFuAI/app.exe", "ShuFuAI/readme.txt"));
+ }
+
+ private Path zip(String... entries) {
+ Path file = tempDir.resolve("pkg-" + UUID.randomUUID() + ".zip");
+ try (ZipOutputStream out = new ZipOutputStream(Files.newOutputStream(file))) {
+ for (String entry : entries) {
+ out.putNextEntry(new ZipEntry(entry));
+ out.write("test".getBytes(java.nio.charset.StandardCharsets.UTF_8));
+ out.closeEntry();
+ }
+ return file;
+ } catch (IOException ex) {
+ throw new IllegalStateException(ex);
+ }
+ }
+
@BeforeAll
static void initializeMybatisMetadata() {
TableInfoHelper.initTableInfo(
@@ -103,6 +148,7 @@ class WorkbenchClientPackageServiceTest {
void confirmRecomputesSha256BeforeInsert() {
String objectKey = PREFIX + "20261024100000123-1.2.3.zip";
when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
+ stubCleanZip();
when(ossStorageService.workbenchClientObjectSha256(objectKey)).thenReturn(SHA);
when(ossStorageService.getWorkbenchClientDownloadUrl(objectKey))
.thenReturn("https://download.aishufu.top/client/" + objectKey);
@@ -153,11 +199,13 @@ class WorkbenchClientPackageServiceTest {
void confirmRejectsDuplicateVersionToPreventSameVersionDifferentBytes() {
String objectKey = PREFIX + "20261024100000123-uuid-1.2.3.zip";
when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
+ stubCleanZip();
when(packageMapper.selectCount(any())).thenReturn(1L);
assertThrows(BusinessException.class, () -> service().confirmPackage(
objectKey, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"));
+ verify(ossStorageService).removeWorkbenchClientObject(objectKey);
verify(ossStorageService, never()).workbenchClientObjectSha256(anyString());
verify(packageMapper, never()).insert(any(WorkbenchClientPackageEntity.class));
}
@@ -166,6 +214,7 @@ class WorkbenchClientPackageServiceTest {
void confirmRejectsVersionLowerThanCurrentLatest() {
String objectKey = PREFIX + "20261024100000123-uuid-1.2.2.zip";
when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
+ stubCleanZip();
when(packageMapper.selectCount(any())).thenReturn(0L);
// 第一次 selectOne 是幂等查(无同对象),第二次才是取当前最新版本
when(packageMapper.selectOne(any()))
@@ -175,10 +224,222 @@ class WorkbenchClientPackageServiceTest {
objectKey, "ShuFuAI-Workbench-1.2.2.zip", "1.2.2"));
assertTrue(ex.getMessage().contains("1.2.3"));
+ verify(ossStorageService).removeWorkbenchClientObject(objectKey);
verify(ossStorageService, never()).workbenchClientObjectSha256(anyString());
verify(packageMapper, never()).insert(any(WorkbenchClientPackageEntity.class));
}
+ @Test
+ void confirmRejectsPackageContainingKeywordShareCredentialConfig() {
+ // CR-02:公开下载的安装包内不得出现 kw_share_cfg.json(明文 API 口令载体)
+ String objectKey = PREFIX + "20261024100000123-uuid-1.2.3.zip";
+ when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
+ when(ossStorageService.downloadWorkbenchClientObjectToTempFile(objectKey))
+ .thenReturn(zip("ShuFuAI/app.exe", "ShuFuAI/config/kw_share_cfg.json"));
+
+ BusinessException ex = assertThrows(BusinessException.class, () -> service().confirmPackage(
+ objectKey, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"));
+
+ assertTrue(ex.getMessage().contains("kw_share_cfg.json"), "错误里要点名命中的凭据文件");
+ verify(ossStorageService).removeWorkbenchClientObject(objectKey);
+ verify(ossStorageService, never()).workbenchClientObjectSha256(anyString());
+ verify(packageMapper, never()).insert(any(WorkbenchClientPackageEntity.class));
+ }
+
+ @Test
+ void confirmRejectsEnvAndPemFiles() {
+ String objectKey = PREFIX + "20261024100000123-uuid-1.2.3.zip";
+ when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
+ when(ossStorageService.downloadWorkbenchClientObjectToTempFile(objectKey))
+ .thenReturn(zip("ShuFuAI/app.exe", "deploy/.env", "cert/server.pem"));
+
+ assertThrows(BusinessException.class, () -> service().confirmPackage(
+ objectKey, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"));
+
+ verify(ossStorageService).removeWorkbenchClientObject(objectKey);
+ verify(packageMapper, never()).insert(any(WorkbenchClientPackageEntity.class));
+ }
+
+ @Test
+ void confirmRejectsNonZipPayloadAndCleansItUp() throws Exception {
+ String objectKey = PREFIX + "20261024100000123-uuid-1.2.3.zip";
+ Path notZip = tempDir.resolve("not-a-zip.zip");
+ Files.writeString(notZip, "this is not a zip");
+ when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
+ when(ossStorageService.downloadWorkbenchClientObjectToTempFile(objectKey)).thenReturn(notZip);
+
+ assertThrows(BusinessException.class, () -> service().confirmPackage(
+ objectKey, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"));
+
+ verify(ossStorageService).removeWorkbenchClientObject(objectKey);
+ verify(packageMapper, never()).insert(any(WorkbenchClientPackageEntity.class));
+ }
+
+ @Test
+ void presignDoesNotLogTheOneTimeUploadUrl() {
+ // CR-21:预签名 URL 是一次性凭据,不得出现在日志里
+ String secretUrl = "https://oss.aishufu.top/client/workbench-client/versions/put?X-Amz-Signature=SECRET-URL-999";
+ when(ossStorageService.presignWorkbenchClientUpload(anyString(), eq(3600))).thenReturn(secretUrl);
+ when(ossStorageService.getWorkbenchClientDownloadUrl(anyString())).thenReturn("download");
+
+ Logger logger = (Logger) LoggerFactory.getLogger(WorkbenchClientPackageService.class);
+ ListAppender appender = new ListAppender<>();
+ appender.start();
+ logger.addAppender(appender);
+ try {
+ Map result = service().presignPackage("pkg.zip", "1.2.3");
+
+ assertEquals(secretUrl, result.get("upload_url"));
+ String logs = String.join("\n", appender.list.stream()
+ .map(ILoggingEvent::getFormattedMessage).toList());
+ assertFalse(logs.contains("SECRET-URL-999"), "预签名 URL 不得入日志: " + logs);
+ } finally {
+ logger.detachAppender(appender);
+ }
+ }
+
+ @Test
+ void concurrentConfirmsOfSameObjectKeyAreIdempotent() throws Exception {
+ String objectKey = PREFIX + "20261024100000123-uuid-1.2.3.zip";
+ when(ossStorageService.workbenchClientObjectSize(objectKey)).thenReturn(1234L);
+ when(ossStorageService.workbenchClientObjectSha256(objectKey)).thenReturn(SHA);
+ when(ossStorageService.getWorkbenchClientDownloadUrl(anyString())).thenReturn("");
+ stubCleanZip();
+ Map rows = new ConcurrentHashMap<>();
+ AtomicLong nextId = new AtomicLong(99L);
+ CountDownLatch insertBarrier = new CountDownLatch(2);
+ when(packageMapper.selectOne(any())).thenAnswer(invocation -> findRow(invocation.getArgument(0), rows));
+ when(packageMapper.selectCount(any())).thenReturn(0L);
+ when(packageMapper.insert(any(WorkbenchClientPackageEntity.class))).thenAnswer(invocation -> {
+ WorkbenchClientPackageEntity entity = invocation.getArgument(0);
+ insertBarrier.countDown();
+ assertTrue(insertBarrier.await(5, TimeUnit.SECONDS), "两路必须都到达 insert 才构成并发");
+ synchronized (rows) {
+ if (rows.containsKey(entity.getObjectKey())) {
+ throw new DuplicateKeyException("uk_workbench_client_object_key");
+ }
+ entity.setId(nextId.incrementAndGet());
+ rows.put(entity.getObjectKey(), entity);
+ return 1;
+ }
+ });
+ when(packageMapper.selectById(any())).thenAnswer(invocation -> rows.values().stream()
+ .filter(row -> row.getId().equals(invocation.getArgument(0))).findFirst().orElse(null));
+
+ List