fix(cr2-backend): 工作台包凭据拒绝与并发幂等、会话/任务终态收口

- CR-02/05/21:confirm 前解包拒绝凭据文件、清理被拒对象;V176 版本唯一键;并发 confirm 幂等
- CR-07/08/09/10:登录世代回读再签、心跳只停续期、终态任务不被失败回调改写、告警先推送再推进基线
- CR-11:品牌 Gating 写操作限平台超管
- CR-18:关键词分页钳制 + V177 四表 DDL
- CR-20:中断恢复标志并上抛
- catch 棘轮按 9 处新增逐条点名更新基线

定向 154 例全绿(0 fail / 0 skip);V174/V175 未回改。
This commit is contained in:
2026-10-26 11:33:25 +08:00
parent 688910f738
commit b5e4c45add
24 changed files with 1206 additions and 41 deletions
@@ -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 {
* 逐行链路的缓存,缺结果的行会走单行回退,所以等待侧超时不需要炸掉整条任务。</li>
* </ul>
* 同批实测 notRethrow 569、logOnly 176、empty 56;气味三格只按这三处实测值抬,形状未放宽。
*
* <p>10-26 抬 1015 -> 1024(第二轮 CR-Fix 2,共 9 处新增 catch,逐处记名):
* <ul>
* <li>{@code WorkbenchClientPackageService.confirmPackage} 一枚:{@code DuplicateKeyException}
* 并发冲突按 objectKey 幂等或转业务错误(RETHROW);</li>
* <li>{@code WorkbenchClientPackageService.rejectCredentialFiles} 两枚:{@code BusinessException}
* 原样重抛、{@code IOException} 清对象后转业务错误(RETHROW);</li>
* <li>{@code WorkbenchClientPackageService.removeRejectedObject} 一枚:{@code RuntimeException}
* 清理失败只 WARN,不让存储异常盖掉业务错误(LOG_ONLY);</li>
* <li>{@code WorkbenchClientPackageService.deleteTempQuietly} 一枚:{@code IOException}
* 删临时文件失败只 WARN(LOG_ONLY);</li>
* <li>{@code OssStorageService.downloadWorkbenchClientObjectToTempFile} 两枚:外层
* {@code Exception} 转 {@code storageFailure} 重抛(RETHROW),内层清理失败只 WARN(LOG_ONLY);</li>
* <li>{@code CostGuardScheduler} 一枚:平台自费告警推送失败只 WARN 并保留基线待下轮重试
* (NOT_RETHROW,log+return);</li>
* <li>{@code SimilarAsinLlmService} 一枚:{@code InterruptedException} 恢复中断位后上抛
* (RETHROW)。</li>
* </ul>
* 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;
/**
@@ -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<Path> files = Files.list(DB_DIR)) {
List<Path> 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"),
"四张表都必须带公司隔离键");
}
}
@@ -103,7 +103,8 @@ class TaskResultFileJobWorkerLogAuditTest {
// 2026-10-24 B28:父任务终态后不再领取/执行/续期,三条出口各有一个阶段字面量。
List<String> 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=");
@@ -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<Path> files = Files.list(DB_DIR)) {
List<Path> 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`)"),
"同版本并发登记必须由数据库唯一键兜底");
}
}
@@ -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);
@@ -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;
}
}
@@ -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))");
}
}
@@ -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<KeywordUsageFilterQuery> 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<KeywordUsageFilterQuery> 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() {
@@ -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);
@@ -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<Throwable> 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 次:合规检查。
@@ -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<Long, TaskDistributedLockService.LockHandle> handles =
(java.util.Map<Long, TaskDistributedLockService.LockHandle>) 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 就永远跑不到,失败任务的结果文件也就永远不生成。
@@ -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)))
@@ -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<ILoggingEvent> appender = new ListAppender<>();
appender.start();
logger.addAppender(appender);
try {
Map<String, Object> 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<String, WorkbenchClientPackageEntity> 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<Object> results = runConcurrently(
() -> service().confirmPackage(objectKey, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"),
() -> service().confirmPackage(objectKey, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"));
assertEquals(1, rows.size(), "同 objectKey 并发 confirm 只能落一行");
for (Object result : results) {
assertTrue(result instanceof Map, "两路都应幂等成功: " + result);
}
assertEquals(((Map<?, ?>) results.get(0)).get("id"), ((Map<?, ?>) results.get(1)).get("id"));
}
@Test
void concurrentConfirmsOfSameVersionDifferentObjectsAllowOnlyOneRow() throws Exception {
String keyA = PREFIX + "20261024100000123-aaa-1.2.3.zip";
String keyB = PREFIX + "20261024100000123-bbb-1.2.3.zip";
when(ossStorageService.workbenchClientObjectSize(anyString())).thenReturn(1234L);
when(ossStorageService.workbenchClientObjectSha256(anyString())).thenReturn(SHA);
when(ossStorageService.getWorkbenchClientDownloadUrl(anyString())).thenReturn("");
stubCleanZip();
Map<String, WorkbenchClientPackageEntity> rows = new ConcurrentHashMap<>();
AtomicLong nextId = new AtomicLong(99L);
CountDownLatch countBarrier = new CountDownLatch(2);
CountDownLatch insertBarrier = new CountDownLatch(2);
AtomicInteger countCalls = new AtomicInteger();
when(packageMapper.selectCount(any())).thenAnswer(invocation -> {
if (countCalls.incrementAndGet() <= 2) {
countBarrier.countDown();
assertTrue(countBarrier.await(5, TimeUnit.SECONDS), "两路都必须先读到 0 才能复现竞态");
}
return 0L;
});
when(packageMapper.selectOne(any())).thenAnswer(invocation -> findRow(invocation.getArgument(0), rows));
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");
}
if (rows.values().stream().anyMatch(row -> row.getVersion().equals(entity.getVersion()))) {
throw new DuplicateKeyException("uk_workbench_client_version");
}
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<Object> results = runConcurrently(
() -> service().confirmPackage(keyA, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"),
() -> service().confirmPackage(keyB, "ShuFuAI-Workbench-1.2.3.zip", "1.2.3"));
assertEquals(1, rows.size(), "同 version 不同 objectKey 并发 confirm 只能落一行");
long success = results.stream().filter(Map.class::isInstance).count();
long rejected = results.stream().filter(BusinessException.class::isInstance).count();
assertEquals(1, success, "必须恰好一路成功: " + results);
assertEquals(1, rejected, "第二路必须是明确的业务错误而非 500: " + results);
// 失败那一路的 512MB 级对象必须被清理,不能悬挂在公开桶
verify(ossStorageService).removeWorkbenchClientObject(anyString());
}
private static WorkbenchClientPackageEntity findRow(Object wrapper,
Map<String, WorkbenchClientPackageEntity> rows) {
if (!(wrapper instanceof AbstractWrapper<?, ?, ?> query)) {
return null;
}
String sql = query.getSqlSegment();
if (sql == null || !sql.contains("object_key")) {
return null;
}
for (Object value : query.getParamNameValuePairs().values()) {
if (value instanceof String key && rows.containsKey(key)) {
return rows.get(key);
}
}
return null;
}
private static List<Object> runConcurrently(ThrowingSupplier first, ThrowingSupplier second)
throws Exception {
CountDownLatch start = new CountDownLatch(1);
ExecutorService pool = Executors.newFixedThreadPool(2);
try {
Future<Object> a = pool.submit(() -> {
start.await();
try {
return first.get();
} catch (Exception ex) {
return ex;
}
});
Future<Object> b = pool.submit(() -> {
start.await();
try {
return second.get();
} catch (Exception ex) {
return ex;
}
});
start.countDown();
return List.of(a.get(10, TimeUnit.SECONDS), b.get(10, TimeUnit.SECONDS));
} finally {
pool.shutdownNow();
}
}
@FunctionalInterface
private interface ThrowingSupplier {
Object get() throws Exception;
}
@Test
void versionComparisonHandlesDifferentSegmentCounts() {
assertTrue(WorkbenchClientPackageService.versionIsLower("1.2.3", "1.2.10"));