fix(phase-5.2): 消项 CR 第二轮 P1/P2/P3(通道/证据链/交付时序/后管证据页)

This commit is contained in:
2026-10-31 21:12:18 +08:00
parent a4e4456b50
commit 91d36327f9
61 changed files with 2833 additions and 311 deletions
@@ -74,7 +74,9 @@ class MigratedSqlEquivalenceTest {
// 99 → 100:Phase 5(AC-19)为任务中心深翻页新增窄锚点语句 {@code TaskCenterQueryMapper#selectTaskPageAnchor}
// (两列投影算页首游标),同轮点名进 NOT_MIGRATED;同轮的 selectTaskPage 改写让它从账本搬进
// NOT_MIGRATED(select 总数不变,只是记账位置换了)。
private static final int XML_SELECT_TOTAL = 100;
// 100 → 102:P1-1 把两条认领查询的通道谓词下推进 SQL,FileTaskMapper 新写 2 条 select,
// 逐条点名进 NOT_MIGRATED(SqlLayeringConventionTest.XML_STATEMENT_TOTAL 同轮 144 → 146)。
private static final int XML_SELECT_TOTAL = 102;
/**
* 不是「从注解搬过来」的语句:注解时代没有原文可对撞,等价性这支只能跳过它们。
@@ -135,7 +137,13 @@ class MigratedSqlEquivalenceTest {
// 所以整行从 migrated-statements.tsv 摘掉、点名到这里(LEDGER_ROWS 85→84)。
// selectTaskPageAnchor —— 本轮新写的两列窄投影,从来没有注解原文可对撞。
"TaskCenterQueryMapper#selectTaskPage",
"TaskCenterQueryMapper#selectTaskPageAnchor");
"TaskCenterQueryMapper#selectTaskPageAnchor",
// P1-1(2026-10-31):客户端兜底拉取与服务端内部认领的通道谓词从 Java 层下推进 SQL
// ——先 limit 取页再 filter(isLocal()) 会让本机单被前面的线上单永久挡死。两条都是
// 本轮新写的 select,从来没有注解原文可对撞(XML_SELECT_TOTAL 同轮 100 → 102,
// SqlLayeringConventionTest.XML_STATEMENT_TOTAL 同轮 144 → 146)。
"FileTaskMapper#selectLocalChannelPendingTasks",
"FileTaskMapper#selectInternalClaimCandidates");
/** 账本 5 列:接口 / 方法 / @Select 种类 / 是否含常量插值 / 注解原文(Java 反转义后那条串)。 */
private static final int LEDGER_COLUMNS = 5;
@@ -91,7 +91,11 @@ class SqlLayeringConventionTest {
// 143 → 144:Phase 5(AC-19/P1-B1)为任务中心深翻页新增窄锚点语句
// {@code TaskCenterQueryMapper#selectTaskPageAnchor}(两列投影算页首游标),
// 同轮登记进 MigratedSqlEquivalenceTest.NOT_MIGRATED(该文件的 XML_SELECT_TOTAL 同轮 99 → 100)。
private static final int XML_STATEMENT_TOTAL = 144;
// 144 → 146:P1-1(2026-10-31)把「这一单交本机还是交线上」的判定从 Java 层下推进 SQL——
// 原形状是先 limit 取页再 filter(isLocal()),混通道时较老的 N 条是 ONLINE 就把本机单永久饿死。
// FileTaskMapper 新写 2 条 select(客户端兜底拉取 / 服务端内部认领),同轮登记进
// MigratedSqlEquivalenceTest.NOT_MIGRATED(该文件 XML_SELECT_TOTAL 同轮 100 → 102)。
private static final int XML_STATEMENT_TOTAL = 146;
/**
* wrapper 里夹带函数级 SQL 的现状("这不是简单单表"的证据),文件名 → 条数:
@@ -0,0 +1,68 @@
package com.nanri.aiimage.common.security;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
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.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
/** P2-4:版本包/教程包发布前的压缩包凭据件扫描。 */
class CredentialPackageGuardTest {
@TempDir
Path tempDir;
private File zipWith(String... entries) throws IOException {
File zip = tempDir.resolve("pkg-" + System.nanoTime() + ".zip").toFile();
try (ZipOutputStream out = new ZipOutputStream(Files.newOutputStream(zip.toPath()))) {
for (String entry : entries) {
out.putNextEntry(new ZipEntry(entry));
out.write("x".getBytes(StandardCharsets.UTF_8));
out.closeEntry();
}
}
return zip;
}
@Test
void nestedDotEnvIsRejected() throws IOException {
File pkg = zipWith("app/readme.txt", "app/conf/.env");
assertEquals("app/conf/.env", CredentialPackageGuard.firstForbiddenEntry(pkg));
}
@Test
void envVariantAndKeyMaterialAreRejected() throws IOException {
assertEquals("docs/.env.production",
CredentialPackageGuard.firstForbiddenEntry(zipWith("docs/.env.production")));
assertEquals("certs/server.PEM",
CredentialPackageGuard.firstForbiddenEntry(zipWith("certs/server.PEM")));
assertEquals("tools/kw_share_cfg.json",
CredentialPackageGuard.firstForbiddenEntry(zipWith("tools/kw_share_cfg.json")));
}
@Test
void ordinaryPackagePasses() throws IOException {
assertNull(CredentialPackageGuard.firstForbiddenEntry(
zipWith("app/readme.txt", "app/config/app.yml", "app/update/update.exe")));
}
@Test
void missingOrNonZipFileFailsClosed() throws IOException {
File notZip = tempDir.resolve("not-a-zip.zip").toFile();
Files.writeString(notZip.toPath(), "plain text");
IOException missing = assertThrows(IOException.class,
() -> CredentialPackageGuard.firstForbiddenEntry(tempDir.resolve("absent.zip").toFile()));
assertTrue(missing.getMessage().contains("missing"));
assertThrows(IOException.class, () -> CredentialPackageGuard.firstForbiddenEntry(notZip));
}
}
@@ -62,7 +62,8 @@ class CatchSilenceRatchetTest {
// 10-30 用户端代理白名单(极客/青果)抬 591 -> 598(7 处逐一记名见 STRICT_TOTAL 上方注释;
// 实测量到 599,多出的 1 格来自已提交的 79b04afd(AdminApiGuardFilter 编码绕过 catch),见同处说明)。
// 10-31 Phase 5.1:证据登记失败回收对象一枚(内层回收失败只 WARN),599 -> 600。
static final int GIVEN_NOT_RETHROW = 600;
// 10-31 CR 消项:证据保留期清理失败 WARN 兜底 + 任务号溢出回落 task_no,新增 2 处非抛分支,600 -> 602。
static final int GIVEN_NOT_RETHROW = 602;
static final int GIVEN_LOG_ONLY = 249;
static final int GIVEN_EMPTY = 56;
@@ -280,7 +281,8 @@ class CatchSilenceRatchetTest {
* 后转业务错误(RETHROW+rethrow 401);内层 catch 是对象回收本身失败只 WARN
* (LOG_ONLY+logOnly 190)。两处误差方向都是「不让孤儿对象永久占桶」。
*/
static final int STRICT_TOTAL = 1057;
// 10-31 CR 消项:版本包/教程包凭据扫描新增 6 处 catch(均转业务异常或带 WARN),1057 -> 1063。
static final int STRICT_TOTAL = 1063;
/**
* 重抛型 catch 的**下限**(不是上限):本轮把两处吞异常改成重抛之后实测 388。
* 这一格只能涨不能跌——它是"异常会往外走"的总量,把它钉成"只许减"就等于拦着别人修吞异常。
@@ -404,7 +406,7 @@ class CatchSilenceRatchetTest {
* (畸形编码保持原样交给容器 400),非本批新增,说明见 STRICT_TOTAL 上方。
*/
// 10-31 Phase 5.1:同 GIVEN_NOT_RETHROW,证据登记补偿回收失败只 WARN,599 -> 600。
static final int STRICT_NOT_RETHROW = 600;
static final int STRICT_NOT_RETHROW = 602;
/**
* 10-17 抬 172 -> 173,出处就是上面点名过的 {@code TaskHeartbeatLivenessService.stamp()}:
* 块体只有「取到 key 名 + log.warn」一句,写心跳证据失败时既不重试也不抛出——
@@ -9,7 +9,6 @@ import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.service.DistributedJobLockService;
import com.nanri.aiimage.common.service.ResultDownloadResolver;
import com.nanri.aiimage.config.AppearancePatentProperties;
import com.nanri.aiimage.config.CollectRoutingProperties;
import com.nanri.aiimage.config.InstanceMetadata;
import com.nanri.aiimage.config.StorageProperties;
import com.nanri.aiimage.modules.appearancepatent.client.AppearancePatentLlmClient;
@@ -68,7 +67,7 @@ class AppearancePatentActivateRoutingTest {
FileTaskEntity task = pendingTask(com.nanri.aiimage.modules.task.model.CollectChannel.LOCAL);
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(task);
when(fileTaskMapper.update(isNull(), any())).thenReturn(1);
AppearancePatentTaskService service = service(new CollectRoutingProperties());
AppearancePatentTaskService service = service();
service.activateTask(TASK_ID, USER_ID);
@@ -85,12 +84,12 @@ class AppearancePatentActivateRoutingTest {
void 线上通道的单_activate_保持后台语义并明确拒绝() {
when(fileTaskMapper.selectById(TASK_ID))
.thenReturn(pendingTask(com.nanri.aiimage.modules.task.model.CollectChannel.ONLINE));
AppearancePatentTaskService service = service(new CollectRoutingProperties());
AppearancePatentTaskService service = service();
BusinessException error = assertThrows(BusinessException.class,
() -> service.activateTask(TASK_ID, USER_ID));
assertTrue(String.valueOf(error.getMessage()).contains("后台自动执行"), error.getMessage());
assertTrue(String.valueOf(error.getMessage()).contains("线上采集"), error.getMessage());
verify(fileTaskMapper, never()).update(isNull(), any());
}
@@ -100,7 +99,7 @@ class AppearancePatentActivateRoutingTest {
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(task);
when(fileTaskMapper.update(isNull(), any())).thenReturn(1);
service(new CollectRoutingProperties()).activateTask(TASK_ID, USER_ID);
service().activateTask(TASK_ID, USER_ID);
verify(taskCacheService).touchTaskHeartbeat(TASK_ID);
}
@@ -115,7 +114,7 @@ class AppearancePatentActivateRoutingTest {
return task;
}
private AppearancePatentTaskService service(CollectRoutingProperties routing) {
private AppearancePatentTaskService service() {
AppearancePatentTaskService service = new AppearancePatentTaskService(
mock(com.nanri.aiimage.modules.file.service.LocalFileStorageService.class),
null,
@@ -139,7 +138,6 @@ class AppearancePatentActivateRoutingTest {
mock(InstanceMetadata.class),
mock(TaskProgressLightAssembler.class),
mock(UserApiSecretService.class));
ReflectionTestUtils.setField(service, "collectRoutingProperties", routing);
return service;
}
@@ -0,0 +1,189 @@
package com.nanri.aiimage.modules.evidence.service;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.service.DistributedJobLockService;
import com.nanri.aiimage.common.task.LockSkipWitness;
import com.nanri.aiimage.config.EvidenceProperties;
import com.nanri.aiimage.modules.evidence.mapper.TaskEvidenceMapper;
import com.nanri.aiimage.modules.evidence.model.entity.TaskEvidenceEntity;
import com.nanri.aiimage.modules.evidence.storage.TaskEvidenceStorageService;
import com.nanri.aiimage.modules.file.service.LocalFileStorageService;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* 证据登记的归属与保留期的执行保证(CR 第二轮 P1-2/P1-7/P2-2)。
*
* <p>P1-2 的判据是「归属先于落桶」:task_id 对得上任务行而 uid 不是行主 ⇒ 403 且
* {@code storage.store} 一次都不许被调——校验晚于落桶的话,每一次拒绝都在证据桶里
* 留一个收不回的孤儿对象。P1-7 的判据是「保留期必须有执行者且不堵车」:拿不到分布式锁
* 要走可聚合出口;单个对象删除失败只牺牲那一行,键集继续往前走。
*/
class TaskEvidenceOwnershipAndRetentionTest {
private static final String TASK_ID = "33062";
private final TaskEvidenceMapper mapper = mock(TaskEvidenceMapper.class);
private final TaskEvidenceStorageService storage = mock(TaskEvidenceStorageService.class);
private final LocalFileStorageService localFiles = mock(LocalFileStorageService.class);
private final EvidenceProperties properties = new EvidenceProperties();
private final FileTaskMapper fileTaskMapper = mock(FileTaskMapper.class);
private final DistributedJobLockService locks = mock(DistributedJobLockService.class);
@TempDir
Path tempDir;
@Test
void 他人任务的证据必须403且一次都不落桶() throws Exception {
stubTaskOwner(7L);
stubUploadableFile();
BusinessException ex = assertThrows(BusinessException.class,
() -> service().register(TASK_ID, 8L, "client", "goods-spider", "evidence.json"));
assertEquals(403, ex.getCode().intValue(), "冒名登记必须 403,不是 500 也不是静默成功");
verify(storage, never()).store(any(), any(), any());
verify(mapper, never()).insert(any(TaskEvidenceEntity.class));
}
@Test
void 无归属uid的登记必须拒绝() throws Exception {
stubTaskOwner(7L);
stubUploadableFile();
assertThrows(BusinessException.class,
() -> service().register(TASK_ID, null, "client", "goods-spider", "evidence.json"));
verify(storage, never()).store(any(), any(), any());
}
@Test
void 本人任务照常登记且登记行带上uid() throws Exception {
stubTaskOwner(7L);
Path file = stubUploadableFile();
when(storage.store(any(), eq(TASK_ID), eq("evidence.json"))).thenReturn(
new TaskEvidenceStorageService.StoredEvidence("task-evidence/k", 3L, "sha", "application/json"));
when(mapper.insert(any(TaskEvidenceEntity.class))).thenReturn(1);
service().register(TASK_ID, 7L, "client", "goods-spider", "evidence.json");
org.mockito.ArgumentCaptor<TaskEvidenceEntity> captor =
org.mockito.ArgumentCaptor.forClass(TaskEvidenceEntity.class);
verify(mapper).insert(captor.capture());
assertEquals(7L, captor.getValue().getUid(), "登记行的 uid 必须是行主本人");
assertEquals(TASK_ID, captor.getValue().getTaskId());
assertTrue(Files.notExists(file) || Files.exists(file), "临时件清理失败只留 warn,不影响登记");
}
@Test
void 客户端本地任务号带uid自证即可登记() throws Exception {
when(fileTaskMapper.selectById(anyLong())).thenReturn(null);
when(fileTaskMapper.selectOne(any())).thenReturn(null);
stubUploadableFile();
when(storage.store(any(), any(), any())).thenReturn(
new TaskEvidenceStorageService.StoredEvidence("task-evidence/k", 3L, "sha", "application/json"));
when(mapper.insert(any(TaskEvidenceEntity.class))).thenReturn(1);
service().register("local-job-abc", 5L, "client", "goods-spider", "evidence.json");
verify(storage).store(any(), eq("local-job-abc"), eq("evidence.json"));
}
@Test
void 零字节证据件拒绝登记() throws Exception {
when(fileTaskMapper.selectById(anyLong())).thenReturn(null);
when(fileTaskMapper.selectOne(any())).thenReturn(null);
Path empty = Files.createFile(tempDir.resolve("empty.png"));
when(localFiles.findLocalSourceFile("empty.png")).thenReturn(empty.toFile());
assertThrows(BusinessException.class,
() -> service().register(TASK_ID, 7L, "client", "goods-spider", "empty.png"));
verify(storage, never()).store(any(), any(), any());
}
@Test
void 同任务证据件数到上限必须拒绝() throws Exception {
when(fileTaskMapper.selectById(anyLong())).thenReturn(null);
when(fileTaskMapper.selectOne(any())).thenReturn(null);
when(mapper.selectCount(any())).thenReturn(50L);
stubUploadableFile();
assertThrows(BusinessException.class,
() -> service().register(TASK_ID, 7L, "client", "goods-spider", "evidence.json"));
verify(storage, never()).store(any(), any(), any());
}
@Test
void 清理拿不到锁必须走可聚合出口且不碰库() {
long before = LockSkipWitness.countOf(TaskEvidenceService.RETENTION_LOCK);
when(locks.tryLock(eq(TaskEvidenceService.RETENTION_LOCK), any())).thenReturn(null);
service().purgeExpired();
assertEquals(before + 1, LockSkipWitness.countOf(TaskEvidenceService.RETENTION_LOCK),
"锁跳过必须有 [lock-skip] 可聚合出口,静默 return 就是 P1-7 的另一半");
verifyNoInteractions(mapper, storage);
}
@Test
void 单个对象删除失败不堵后面的行() {
when(locks.tryLock(eq(TaskEvidenceService.RETENTION_LOCK), any()))
.thenReturn(mock(DistributedJobLockService.LockHandle.class));
TaskEvidenceEntity first = evidenceRow(1L, "k1");
TaskEvidenceEntity stuck = evidenceRow(2L, "k2");
TaskEvidenceEntity third = evidenceRow(3L, "k3");
when(mapper.selectList(any())).thenReturn(List.of(first, stuck, third), List.of());
doThrow(new RuntimeException("oss unavailable")).when(storage).delete("k2");
when(mapper.deleteById(anyLong())).thenReturn(1);
service().purgeExpired();
verify(mapper).deleteById(1L);
verify(mapper, never()).deleteById(2L);
verify(mapper).deleteById(3L);
}
private TaskEvidenceService service() {
return new TaskEvidenceService(mapper, storage, localFiles, properties, fileTaskMapper, locks);
}
private void stubTaskOwner(long uid) {
FileTaskEntity row = new FileTaskEntity();
row.setId(Long.parseLong(TASK_ID));
row.setUserId(uid);
when(fileTaskMapper.selectById(Long.parseLong(TASK_ID))).thenReturn(row);
}
private Path stubUploadableFile() throws Exception {
Path file = tempDir.resolve("evidence.json");
Files.writeString(file, "{\"traceback\": \"boom\"}");
when(localFiles.findLocalSourceFile("evidence.json")).thenReturn(file.toFile());
return file;
}
private static TaskEvidenceEntity evidenceRow(long id, String objectKey) {
TaskEvidenceEntity row = new TaskEvidenceEntity();
row.setId(id);
row.setTaskId(TASK_ID);
row.setObjectKey(objectKey);
return row;
}
}
@@ -0,0 +1,145 @@
package com.nanri.aiimage.modules.softwareversion.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.modules.file.service.LocalFileStorageService;
import com.nanri.aiimage.modules.file.service.oss.OssStorageService;
import com.nanri.aiimage.modules.softwareversion.mapper.SoftwareVersionMapper;
import com.nanri.aiimage.modules.softwareversion.model.entity.SoftwareVersionEntity;
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.mockito.ArgumentCaptor;
import org.springframework.test.util.ReflectionTestUtils;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
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.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 版本包「分片拼装件 → confirm 搬桶落库」这条通道的契约(CR 第二轮 P1-8)。
*
* <p>新重载 {@code confirmSoftwareVersion(version, fileKey)} 写好之后长期没有任何执行证据
* (后端整量绿也覆盖不到没被调用的分支)。幂等命中、临时件清理、缺件拒绝这三条是发版
* 判据:任何一条破掉,要么重试会插出双版本行,要么临时件永远堆在盘上。
*/
class SoftwareVersionServiceChunkConfirmTest {
private final SoftwareVersionMapper versionMapper = mock(SoftwareVersionMapper.class);
private final OssStorageService ossStorageService = mock(OssStorageService.class);
private final LocalFileStorageService localFiles = mock(LocalFileStorageService.class);
@TempDir
Path tempDir;
@BeforeAll
static void initializeMybatisMetadata() {
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""), SoftwareVersionEntity.class);
}
private SoftwareVersionService service() {
SoftwareVersionService service = new SoftwareVersionService(versionMapper, ossStorageService);
ReflectionTestUtils.setField(service, "localFileStorageService", localFiles);
return service;
}
@Test
void 分片确认搬桶落库并标记最新且临时件清掉() throws Exception {
Path zip = writeZip("4.0.69.zip");
when(localFiles.findLocalSourceFile("chunk-abc")).thenReturn(zip.toFile());
when(ossStorageService.uploadSoftwareVersionPackage(any(), any()))
.thenReturn("https://oss.aishufu.top/client/nanri-image/versions/4.0.69.zip");
when(versionMapper.insert(any(SoftwareVersionEntity.class))).thenAnswer(invocation -> {
((SoftwareVersionEntity) invocation.getArgument(0)).setId(300L);
return 1;
});
when(versionMapper.selectById(300L)).thenReturn(null);
service().confirmSoftwareVersion("4.0.69", "chunk-abc");
ArgumentCaptor<SoftwareVersionEntity> captor = ArgumentCaptor.forClass(SoftwareVersionEntity.class);
verify(versionMapper).insert(captor.capture());
assertEquals("4.0.69", captor.getValue().getVersion());
assertNotEquals("", captor.getValue().getSha256(), "落库必须带拼装件的 sha256");
verify(versionMapper).markLatestById(300L);
assertFalse(Files.exists(zip), "确认成功后临时拼装件必须删掉,否则每次重传都堆一份");
}
@Test
void 同版本重复确认命中幂等不重复搬桶() throws Exception {
Path zip = writeZip("4.0.69.zip");
when(localFiles.findLocalSourceFile("chunk-abc")).thenReturn(zip.toFile());
SoftwareVersionEntity existing = new SoftwareVersionEntity();
existing.setId(9L);
existing.setVersion("4.0.69");
when(versionMapper.selectOne(any())).thenReturn(existing);
service().confirmSoftwareVersion("4.0.69", "chunk-abc");
verify(ossStorageService, never()).uploadSoftwareVersionPackage(any(), any());
verify(versionMapper, never()).insert(any(SoftwareVersionEntity.class));
verify(versionMapper, never()).markLatestById(any());
assertFalse(Files.exists(zip), "幂等命中也要把临时件清掉");
}
@Test
void 拼装件缺失必须拒绝且不落库() {
when(localFiles.findLocalSourceFile("chunk-gone")).thenReturn(null);
assertThrows(RuntimeException.class,
() -> service().confirmSoftwareVersion("4.0.69", "chunk-gone"));
verify(versionMapper, never()).insert(any(SoftwareVersionEntity.class));
}
@Test
void 非zip拼装件必须拒绝() throws Exception {
Path notZip = writeTempFile("payload.txt", "not a zip");
when(localFiles.findLocalSourceFile("chunk-abc")).thenReturn(notZip.toFile());
assertThrows(RuntimeException.class,
() -> service().confirmSoftwareVersion("4.0.69", "chunk-abc"));
verify(ossStorageService, never()).uploadSoftwareVersionPackage(any(), any());
}
@Test
void 零字节拼装件必须拒绝() throws Exception {
Path empty = Files.createFile(tempDir.resolve("4.0.69.zip"));
when(localFiles.findLocalSourceFile("chunk-abc")).thenReturn(empty.toFile());
assertThrows(RuntimeException.class,
() -> service().confirmSoftwareVersion("4.0.69", "chunk-abc"));
assertTrue(Files.exists(empty), "拒绝分支不许动调用方的临时件(排查要用)");
}
/** P2-4 起 confirm 会读 zip 中央目录,测试夹具必须是真 zip 而不是 PK 魔数文本。 */
private Path writeZip(String name) throws Exception {
Path file = tempDir.resolve(name);
try (ZipOutputStream out = new ZipOutputStream(Files.newOutputStream(file))) {
out.putNextEntry(new ZipEntry("readme.txt"));
out.write("package".getBytes(StandardCharsets.UTF_8));
out.closeEntry();
}
return file;
}
private Path writeTempFile(String name, String content) throws Exception {
Path file = tempDir.resolve(name);
Files.writeString(file, content, StandardCharsets.UTF_8);
return file;
}
}
@@ -0,0 +1,157 @@
package com.nanri.aiimage.modules.task.mapper;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import org.apache.ibatis.builder.xml.XMLMapperBuilder;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.session.Configuration;
import org.junit.jupiter.api.Test;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* V183 采集通道的谓词形状(CR 第二轮 P1-1)。
*
* <p><b>为什么钉 SQL 而不是钉行为</b>:这两条查询的执行方判定必须在 {@code WHERE} 里、
* 在 {@code LIMIT} 之前。写成「先 limit 取页、回 Java 再 {@code filter(isLocal())}」时,
* 混通道排队里只要较老的 N 条(出厂 {@code client-task-pull.limit=5})是 ONLINE,
* 本机通道的单本轮及以后都领不到——不是延后,是排到队尾之前永久饿死。
* 而 mock 掉 {@code selectList} 的返回让「取页与过滤的先后」在用例里根本看不见,
* 这就是它活过后端整量的原因(现网 {@code enabled=false} 也没能掩盖住)。
* 这里用真 {@code XMLMapperBuilder} 解析、向真 {@code BoundSql} 断言,判据=
* 把谓词挪出 {@code WHERE} 或挪到 {@code LIMIT} 之后,本格直接红。
*
* <p>没有数据库也成立的另一面:{@code ?} 的个数与顺序被钉死,抽掉通道谓词就少两个占位符。
*/
class FileTaskMapperChannelSqlTest {
private static final String XML = "mapper/task/FileTaskMapper.xml";
private static final String NS = "com.nanri.aiimage.modules.task.mapper.FileTaskMapper";
private static final List<String> MODULE_TYPES = List.of("APPEARANCE_PATENT", "SIMILAR_ASIN");
private static final List<String> LOCAL_DEFAULTS = List.of("APPEARANCE_PATENT", "SIMILAR_ASIN");
@Test
void 客户端拉取的通道谓词在WHERE里且发生在LIMIT之前() throws Exception {
String sql = render("selectLocalChannelPendingTasks", clientParams(2));
int at = sql.indexOf("CASE WHEN collect_channel IN ('LOCAL', 'ONLINE')");
assertTrue(at > 0, () -> "通道判定不在 SQL 里(回到 Java filter 就是 P1-1 复发): " + sql);
int limit = sql.lastIndexOf("LIMIT ?");
assertTrue(limit > at, () -> "通道谓词必须出现在 LIMIT 之前,否则取到的那一页里没有本机单: " + sql);
assertTrue(sql.indexOf("ORDER BY created_at ASC") < limit,
() -> "排序必须在 LIMIT 之前,否则取页不是「最早创建的本机单」: " + sql);
assertEquals("SELECT id, module_type, collect_channel, created_at FROM biz_file_task"
+ " WHERE user_id = ? AND status = ? AND module_type IN (?, ?) AND created_at < ?"
+ " AND CASE WHEN collect_channel IN ('LOCAL', 'ONLINE') THEN collect_channel"
+ " WHEN module_type IN (?, ?) THEN 'LOCAL' ELSE 'ONLINE' END = 'LOCAL'"
+ " ORDER BY created_at ASC LIMIT ?", sql,
"取页形状变了:通道谓词必须与 status/模块/时间窗口同在 WHERE 里,且 LIMIT 之后没有任何过滤面");
}
@Test
void 内部认领把本机让位做成SQL侧OR窗口而不是Java二次过滤() throws Exception {
String sql = render("selectInternalClaimCandidates", internalParams(2));
assertTrue(sql.contains("(NOT (CASE") && sql.contains("= 'LOCAL') OR created_at <= ?)"),
() -> "让位窗口不在 SQL 里:整页都是「本机通道且没等满兜底窗口」时,本轮线上单零吞吐: " + sql);
assertTrue(sql.indexOf("created_at < ?") < sql.indexOf("created_at <= ?"),
() -> "基础等待窗口与兜底窗口必须都在 LIMIT 之前: " + sql);
assertTrue(sql.lastIndexOf("created_at <= ?") < sql.lastIndexOf("LIMIT ?"),
() -> "兜底窗口谓词必须发生在 LIMIT 之前: " + sql);
}
@Test
void 通道判定用CASE兜模块默认而不是裸等值() throws Exception {
String sql = render("selectLocalChannelPendingTasks", clientParams(2));
// 裸等值(collect_channel = 'LOCAL' 或 NOT (collect_channel = 'LOCAL'))在列为 NULL 时吃三值
// 逻辑变成 UNKNOWN:被默认兜成 ONLINE 的模块(COLLECT_DATA 等)会在 NOT 之后永久领不到。
assertFalse(sql.contains("collect_channel = ?"), () -> "通道值被参数化后 CASE 的兜法就散了: " + sql);
assertFalse(sql.contains("collect_channel = 'LOCAL' OR"),
() -> "OR 形状的裸等值谓词对 NULL 列失明: " + sql);
assertTrue(sql.contains("ELSE 'ONLINE' END"), () -> "CASE 缺 ELSE=不可识别值不再兜默认: " + sql);
}
@Test
void 取页投影只有认领需要的四列() throws Exception {
String sql = render("selectLocalChannelPendingTasks", clientParams(2));
assertTrue(sql.startsWith("SELECT id, module_type, collect_channel, created_at FROM biz_file_task"),
() -> "投影列清单变了(整行拉回来会把 result_json 这类大列带进兜底轮询): " + sql);
}
@Test
void 占位符数与两条语句的谓词形状逐一对撞() throws Exception {
// 客户端:user_id + status + 2 模块 + cutoff + 2 默认模块 + limit = 8
assertEquals(8, questionMarks("selectLocalChannelPendingTasks", clientParams(2)),
"少 2 个就是通道谓词被抽掉了(P1-1 复发),多 2 个是模块清单被写了两遍");
// 内部认领:status + 2 模块 + cutoff + 2 默认模块 + localCutoff + limit = 8
assertEquals(8, questionMarks("selectInternalClaimCandidates", internalParams(2)),
"内部认领的兜底窗口比客户端多一条 cutoff、少一个 user_id");
}
@Test
void V184补齐两条取页路径的索引并明写通道列不进索引() throws Exception {
Path migration = moduleRoot().resolve("src/main/resources/db/V184__collect_pull_and_evidence_indexes.sql");
assertTrue(Files.exists(migration), "V184 缺失:P1-1 的下推查询没有索引承接,P2-1 的保留期扫描仍全表");
String sql = Files.readString(migration, StandardCharsets.UTF_8);
assertTrue(sql.contains("ADD INDEX idx_biz_file_task_status_module_created (status, module_type, created_at)"),
() -> "认领取页索引的列组合变了: " + sql);
assertTrue(sql.contains("ADD INDEX idx_task_evidence_created_at (created_at)"),
() -> "证据保留期是单列 created_at 谓词,前导列不符就还是全表扫: " + sql);
assertFalse(sql.contains("idx_task_collect_channel"),
"通道列有意不进索引:CASE 表达式谓词不吃索引,把 collect_channel 夹在 module_type 与"
+ " created_at 之间反而打断 ORDER BY created_at 的索引有序性");
}
private static int questionMarks(String id, Map<String, Object> params) throws Exception {
return (int) render(id, params).chars().filter(c -> c == '?').count();
}
private static String render(String id, Map<String, Object> params) throws Exception {
MappedStatement statement = parse().getMappedStatement(NS + "." + id);
// MyBatis 把 foreach 展开成 `IN ( ? , ? )`,这里收成 `IN (?,?)` 好让判据读得下去。
return statement.getBoundSql(params).getSql().replaceAll("\\s+", " ").trim()
.replace("( ", "(").replace(" )", ")").replace(" ,", ",");
}
private static Map<String, Object> clientParams(int modules) {
return Map.of("userId", 1095L,
"status", "PENDING",
"moduleTypes", MODULE_TYPES.subList(0, modules),
"localDefaultModules", LOCAL_DEFAULTS,
"cutoff", LocalDateTime.now().minusMinutes(5),
"limit", 5);
}
private static Map<String, Object> internalParams(int modules) {
return Map.of("status", "PENDING",
"moduleTypes", MODULE_TYPES.subList(0, modules),
"localDefaultModules", LOCAL_DEFAULTS,
"cutoff", LocalDateTime.now().minusMinutes(2),
"localCutoff", LocalDateTime.now().minusMinutes(30),
"limit", 5);
}
private static Configuration parse() throws Exception {
MybatisConfiguration configuration = new MybatisConfiguration();
try (InputStream in = Resources.getResourceAsStream(XML)) {
new XMLMapperBuilder(in, configuration, XML, configuration.getSqlFragments()).parse();
}
return configuration;
}
private static Path moduleRoot() {
Path here = Path.of("").toAbsolutePath();
return Files.isDirectory(here.resolve("src/main/resources")) ? here : here.getParent();
}
}
@@ -3,9 +3,12 @@ package com.nanri.aiimage.modules.task.model;
import com.nanri.aiimage.config.CollectRoutingProperties;
import org.junit.jupiter.api.Test;
import java.util.List;
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.assertTrue;
/**
* V183 任务级采集通道的判据(建单写入、认领读取、脏值兜底)。
@@ -27,6 +30,24 @@ class CollectChannelTest {
assertFalse(CollectChannel.defaultFor(" ").isLocal());
}
/**
* P1-1 把通道判定下推进 SQL 之后,「哪些模块默认本机」这份清单被喂进 mapper 的 CASE。
* 判据=清单内必被 {@link CollectChannel#defaultFor} 读作本机、清单外必不读作本机。
* 谁在 defaultFor 里另加一个模块而忘了同步清单,SQL 就会把那模块的历史单兜成线上:
* 界面显示「本机采集」、客户端却永远领不到。
*/
@Test
void 本机默认模块清单与defaultFor同源() {
assertEquals(List.of(CollectRoutingProperties.MODULE_APPEARANCE_PATENT,
CollectRoutingProperties.MODULE_SIMILAR_ASIN), CollectChannel.localDefaultModuleTypes());
for (String module : CollectChannel.localDefaultModuleTypes()) {
assertTrue(CollectChannel.defaultFor(module).isLocal(), module + " 在清单里却不被判本机");
}
for (String module : List.of("DEDUPE", "COLLECT_DATA", "SHOP_DATA_CRAWL", "PUBLISH")) {
assertFalse(CollectChannel.defaultFor(module).isLocal(), module + " 不在清单里却读成本机");
}
}
@Test
void 模块默认大小写与空白不影响判定() {
assertEquals(CollectChannel.LOCAL, CollectChannel.defaultFor("similar_asin"));
@@ -9,6 +9,7 @@ import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.config.InstanceMetadata;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.CollectChannel;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.vo.TaskClientPullVo;
import com.nanri.aiimage.modules.task.spi.ClientTaskPullSpi;
@@ -29,7 +30,9 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
@@ -68,7 +71,7 @@ class TaskClientPullServiceTest {
@Test
void 认领成功后返回载荷并写_RUNNING_与_owner() {
FileTaskEntity candidate = task(11L, "SIMILAR_ASIN");
when(fileTaskMapper.selectList(any())).thenReturn(List.of(candidate));
stubPullCandidates(candidate);
when(fileTaskMapper.update(isNull(), any())).thenReturn(1);
when(fileTaskMapper.selectById(11L)).thenReturn(candidate);
StubHandler handler = new StubHandler("SIMILAR_ASIN", payload("similar-asin-run"));
@@ -88,17 +91,16 @@ class TaskClientPullServiceTest {
assertTrue(params.containsValue("RUNNING"), "认领必须写入 RUNNING");
assertTrue(sqlSetOf(captor.getValue()).contains("owner_instance_id"), "认领必须接管归属实例");
ArgumentCaptor<Wrapper<FileTaskEntity>> selectCaptor = wrapperCaptor();
verify(fileTaskMapper).selectList(selectCaptor.capture());
Map<String, Object> selectParams = paramsOf(selectCaptor.getValue());
assertTrue(selectParams.containsValue("PENDING"), "候选只挑 PENDING");
assertTrue(selectParams.containsValue(USER_ID), "候选限定任务所属用户");
assertTrue(selectCaptor.getValue().getSqlSegment().contains("created_at"), "候选要有创建时间窗口");
// 取页形状(通道谓词在 WHERE、LIMIT 之前)由 FileTaskMapperChannelSqlTest 向真 BoundSql 断言;
// 这里钉「调用的是哪条具名查询、传了什么」,两者合起来才挡住 P1-1 复发。
verify(fileTaskMapper).selectLocalChannelPendingTasks(eq(USER_ID), eq("PENDING"),
eq(List.of("SIMILAR_ASIN", "COLLECT_DATA")), eq(CollectChannel.localDefaultModuleTypes()),
any(LocalDateTime.class), eq(5));
}
@Test
void 页面抢先认领后不再返回任务() {
when(fileTaskMapper.selectList(any())).thenReturn(List.of(task(11L, "SIMILAR_ASIN")));
stubPullCandidates(task(11L, "SIMILAR_ASIN"));
when(fileTaskMapper.update(isNull(), any())).thenReturn(0);
StubHandler handler = new StubHandler("SIMILAR_ASIN", payload("similar-asin-run"));
@@ -112,7 +114,7 @@ class TaskClientPullServiceTest {
@Test
void 组装不出载荷时任务标失败() {
FileTaskEntity candidate = task(11L, "SIMILAR_ASIN");
when(fileTaskMapper.selectList(any())).thenReturn(List.of(candidate));
stubPullCandidates(candidate);
when(fileTaskMapper.update(isNull(), any())).thenReturn(1);
when(fileTaskMapper.selectById(11L)).thenReturn(candidate);
@@ -127,7 +129,7 @@ class TaskClientPullServiceTest {
@Test
void 组装抛异常时任务标失败且不抛出() {
FileTaskEntity candidate = task(11L, "SIMILAR_ASIN");
when(fileTaskMapper.selectList(any())).thenReturn(List.of(candidate));
stubPullCandidates(candidate);
when(fileTaskMapper.update(isNull(), any())).thenReturn(1);
when(fileTaskMapper.selectById(11L)).thenReturn(candidate);
StubHandler broken = new StubHandler("SIMILAR_ASIN", null, new IllegalStateException("boom"));
@@ -142,7 +144,7 @@ class TaskClientPullServiceTest {
@Test
void 白名单模块未实现兜底时跳过且不改状态() {
when(fileTaskMapper.selectList(any())).thenReturn(List.of(task(21L, "COLLECT_DATA")));
stubPullCandidates(task(21L, "COLLECT_DATA"));
List<TaskClientPullVo> result = service(new StubHandler("SIMILAR_ASIN", payload("similar-asin-run")))
.pullPendingTasks(USER_ID);
@@ -190,86 +192,97 @@ class TaskClientPullServiceTest {
}
}
// ------------------------------------------------------------ 本地采集路由(2026-10-29)
// ---------------------------------------------------- 本地采集路由(2026-10-29 建档,2026-10-31 下推 SQL)
/**
* 客户端拉取只走带通道谓词的具名查询,服务侧不再挑第二遍。
*
* <p>这里喂一条通道写着 ONLINE 的行——真 SQL 不会返回它——为的是钉住「Java 里没有第二道
* {@code filter(isLocal())}」。P1-1 的原形状就是先 {@code limit 5} 取页再过滤:那一道过滤
* 看不见 limit,也就没人替它保证「先筛后取页」,混通道时较老的 N 条是线上单就把本机单永久
* 挡在队尾之后。谓词本身的位置由 {@code FileTaskMapperChannelSqlTest} 向真 BoundSql 钉。
*/
@Test
void 客户端兜底拉取不领线上通道的单() {
FileTaskEntity online = task(11L, "SIMILAR_ASIN", 10L);
online.setCollectChannel("ONLINE");
when(fileTaskMapper.selectList(any())).thenReturn(List.of(online));
void 客户端拉取把通道判定整个交给SQL不做二次过滤() {
FileTaskEntity row = task(11L, "SIMILAR_ASIN", 10L);
row.setCollectChannel("ONLINE");
stubPullCandidates(row);
when(fileTaskMapper.update(isNull(), any())).thenReturn(1);
when(fileTaskMapper.selectById(11L)).thenReturn(row);
List<TaskClientPullVo> result = serviceWithRouting(defaultRouting(),
new StubHandler("SIMILAR_ASIN", payload("similar-asin-run"))).pullPendingTasks(USER_ID);
assertTrue(result.isEmpty(), "这一单选了线上采集,客户端领了就是抢跑");
verify(fileTaskMapper, never()).update(isNull(), any());
assertEquals(1, result.size(), "候选页由 SQL 侧谓词筛好,服务再判一遍就是 P1-1 复发");
}
/**
* 内部认领同样把让位判定交给 SQL:喂一条「还在让位窗口内的本机单」,服务必须照领。
*/
@Test
void 客户端兜底拉取照领本机通道的单() {
FileTaskEntity local = task(11L, "SIMILAR_ASIN", 10L);
local.setCollectChannel("LOCAL");
when(fileTaskMapper.selectList(any())).thenReturn(List.of(local));
when(fileTaskMapper.update(isNull(), any())).thenReturn(1);
when(fileTaskMapper.selectById(11L)).thenReturn(local);
List<TaskClientPullVo> result = serviceWithRouting(defaultRouting(),
new StubHandler("SIMILAR_ASIN", payload("similar-asin-run"))).pullPendingTasks(USER_ID);
assertEquals(1, result.size(), "本机通道的单必须能被在线客户端领走");
}
@Test
void 内部认领对本机通道让位到兜底窗口() {
void 内部认领不在Java里做让位过滤() {
com.nanri.aiimage.config.CollectRoutingProperties routing =
new com.nanri.aiimage.config.CollectRoutingProperties();
routing.setLinuxFallbackMinutes(30L);
FileTaskEntity localTask = task(11L, "SIMILAR_ASIN", 10L);
localTask.setCollectChannel("LOCAL");
when(fileTaskMapper.selectList(any())).thenReturn(List.of(localTask));
List<TaskClientPullVo> result = serviceWithRouting(routing,
new StubHandler("SIMILAR_ASIN", payload("similar-asin-run")))
.pullPendingTasksInternal(List.of("SIMILAR_ASIN"));
assertTrue(result.isEmpty(), "本机通道的单在兜底窗口内必须让位给本地客户端");
verify(fileTaskMapper, never()).update(isNull(), any());
}
@Test
void 内部认领超过兜底窗口后接管本机通道的单() {
com.nanri.aiimage.config.CollectRoutingProperties routing =
new com.nanri.aiimage.config.CollectRoutingProperties();
routing.setLinuxFallbackMinutes(30L);
FileTaskEntity candidate = task(11L, "SIMILAR_ASIN", 40L);
candidate.setCollectChannel("LOCAL");
when(fileTaskMapper.selectList(any())).thenReturn(List.of(candidate));
FileTaskEntity row = task(21L, "COLLECT_DATA", 10L);
row.setCollectChannel("LOCAL");
stubInternalCandidates(row);
when(fileTaskMapper.update(isNull(), any())).thenReturn(1);
when(fileTaskMapper.selectById(11L)).thenReturn(candidate);
List<TaskClientPullVo> result = serviceWithRouting(routing,
new StubHandler("SIMILAR_ASIN", payload("similar-asin-run")))
.pullPendingTasksInternal(List.of("SIMILAR_ASIN"));
assertEquals(1, result.size(), "本机长时间没人领,Linux 必须兜底接管");
}
@Test
void 内部认领对线上通道不受兜底窗口影响() {
com.nanri.aiimage.config.CollectRoutingProperties routing =
new com.nanri.aiimage.config.CollectRoutingProperties();
routing.setLinuxFallbackMinutes(30L);
FileTaskEntity candidate = task(21L, "COLLECT_DATA", 10L);
candidate.setCollectChannel("ONLINE");
when(fileTaskMapper.selectList(any())).thenReturn(List.of(candidate));
when(fileTaskMapper.update(isNull(), any())).thenReturn(1);
when(fileTaskMapper.selectById(21L)).thenReturn(candidate);
when(fileTaskMapper.selectById(21L)).thenReturn(row);
List<TaskClientPullVo> result = serviceWithRouting(routing,
new StubHandler("COLLECT_DATA", payload("collect-data-run")))
.pullPendingTasksInternal(List.of("COLLECT_DATA"));
assertEquals(1, result.size(), "选了线上的单子不能被本地优先的窗口拖住");
assertEquals(1, result.size(), "让位窗口是 SQL 的 OR 分支,不是取页之后的 Java 过滤");
}
/**
* 两道窗口分别下传:基础等待窗口(给「建完就想删」留余地)与本机兜底窗口(Linux 接管点)。
* 兜底窗口配得比基础窗口还小时取基础窗口——这条夹逼原先在 Java 里,下推后仍得由服务算好。
*/
@Test
void 内部认领下传两道cutoff且兜底窗口不越基础窗口() {
com.nanri.aiimage.config.CollectRoutingProperties narrow =
new com.nanri.aiimage.config.CollectRoutingProperties();
narrow.setLinuxFallbackMinutes(1L);
serviceWithRouting(narrow, new StubHandler("SIMILAR_ASIN", payload("similar-asin-run")))
.pullPendingTasksInternal(List.of("SIMILAR_ASIN"));
ArgumentCaptor<LocalDateTime> cutoff = ArgumentCaptor.forClass(LocalDateTime.class);
ArgumentCaptor<LocalDateTime> localCutoff = ArgumentCaptor.forClass(LocalDateTime.class);
verify(fileTaskMapper).selectInternalClaimCandidates(eq("PENDING"), eq(List.of("SIMILAR_ASIN")),
eq(CollectChannel.localDefaultModuleTypes()), cutoff.capture(), localCutoff.capture(), eq(5));
assertEquals(cutoff.getValue(), localCutoff.getValue(),
"兜底窗口 1 分钟短于基础窗口 2 分钟时按 2 分钟算,否则「建完就能删」的余地被越过");
}
@Test
void 兜底窗口长于基础窗口时按自身下传() {
com.nanri.aiimage.config.CollectRoutingProperties wide =
new com.nanri.aiimage.config.CollectRoutingProperties();
wide.setLinuxFallbackMinutes(30L);
serviceWithRouting(wide, new StubHandler("SIMILAR_ASIN", payload("similar-asin-run")))
.pullPendingTasksInternal(List.of("SIMILAR_ASIN"));
ArgumentCaptor<LocalDateTime> cutoff = ArgumentCaptor.forClass(LocalDateTime.class);
ArgumentCaptor<LocalDateTime> localCutoff = ArgumentCaptor.forClass(LocalDateTime.class);
verify(fileTaskMapper).selectInternalClaimCandidates(eq("PENDING"), eq(List.of("SIMILAR_ASIN")),
eq(CollectChannel.localDefaultModuleTypes()), cutoff.capture(), localCutoff.capture(), eq(5));
assertTrue(localCutoff.getValue().isBefore(cutoff.getValue()),
"30 分钟的让位窗口必须比 2 分钟的基础窗口更早,否则 Linux 会抢在本地客户端前面双跑");
}
private void stubPullCandidates(FileTaskEntity... rows) {
when(fileTaskMapper.selectLocalChannelPendingTasks(any(), any(), any(), any(), any(), anyInt()))
.thenReturn(List.of(rows));
}
private void stubInternalCandidates(FileTaskEntity... rows) {
when(fileTaskMapper.selectInternalClaimCandidates(any(), any(), any(), any(), any(), anyInt()))
.thenReturn(List.of(rows));
}
private TaskClientPullService service(ClientTaskPullSpi... handlers) {
@@ -21,7 +21,7 @@ import java.util.List;
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.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.isNull;
@@ -76,29 +76,33 @@ class TaskFileJobTerminalTaskGuardTest {
}
@Test
void claimRunningRejectsJobWhoseTaskIsFailed() {
TaskFileJobEntity failedTaskJob = job(11L, 500L);
when(taskFileJobMapper.selectById(11L)).thenReturn(failedTaskJob);
void claimRunningStillDeliversWhenParentTaskIsTerminal() {
TaskFileJobEntity terminalTaskJob = job(11L, 500L);
TaskFileJobEntity running = job(11L, 500L);
running.setStatus("RUNNING");
when(taskFileJobMapper.selectById(11L)).thenReturn(terminalTaskJob, running);
when(taskFileJobMapper.selectFileTaskStatus(500L)).thenReturn("FAILED");
when(taskFileJobMapper.update(isNull(), any(LambdaUpdateWrapper.class))).thenReturn(1);
assertNull(service.claimRunning(11L), "终态任务的作业不得被 claim 成 RUNNING");
TaskFileJobEntity claimed = service.claimRunning(11L);
assertNotNull(claimed, "P1-13:父任务终态也要放行出表作业");
assertEquals("RUNNING", claimed.getStatus());
@SuppressWarnings("unchecked")
ArgumentCaptor<LambdaUpdateWrapper<TaskFileJobEntity>> captor =
ArgumentCaptor.forClass(LambdaUpdateWrapper.class);
verify(taskFileJobMapper, times(1)).update(isNull(), captor.capture());
LambdaUpdateWrapper<TaskFileJobEntity> wrapper = captor.getValue();
assertTrue(hasParam(wrapper, "FAILED"), "必须把作业拉成 FAILED,下一轮扫描才捞不到");
assertTrue(hasParam(wrapper, 5), "retry_count 必须一次拉满到上限");
assertFalse(hasParam(wrapper, "RUNNING"), "不得再翻转成 RUNNING");
assertTrue(hasParam(wrapper, "RUNNING"), "终态父任务不再把出表作业拉成 FAILED");
assertFalse(hasParam(wrapper, "FAILED"), "终态只停心跳续期,不改写给出表作业");
assertTrue(wrapper.getSqlSet().contains("terminal_callback_at"),
"terminal_callback_at 必须显式清空:留给兜底扫描出部分结果,失败任务仍可下载");
assertTrue(hasParam(wrapper, null), "terminal_callback_at 置空后兜底扫描才捞得到这一行");
"正常认领必须清空 terminal_callback_at,失败兜底扫描才捞得到");
assertTrue(hasParam(wrapper, null));
}
@Test
void claimCandidatesSkipsTerminalTaskAndKeepsActiveOne() {
void claimCandidatesClaimsBothTerminalAndActiveTasks() {
TaskFileJobEntity terminal = job(21L, 500L);
TaskFileJobEntity active = job(22L, 501L);
when(taskFileJobMapper.selectList(any(LambdaQueryWrapper.class)))
@@ -106,23 +110,25 @@ class TaskFileJobTerminalTaskGuardTest {
when(taskFileJobMapper.selectFileTaskStatus(500L)).thenReturn("FAILED");
when(taskFileJobMapper.selectFileTaskStatus(501L)).thenReturn("RUNNING");
when(taskFileJobMapper.update(isNull(), any(LambdaUpdateWrapper.class))).thenReturn(1, 1);
TaskFileJobEntity claimedTerminal = job(21L, 500L);
claimedTerminal.setStatus("RUNNING");
TaskFileJobEntity claimedActive = job(22L, 501L);
claimedActive.setStatus("RUNNING");
when(taskFileJobMapper.selectBatchIds(any())).thenReturn(List.of(claimedActive));
when(taskFileJobMapper.selectBatchIds(any())).thenReturn(List.of(claimedTerminal, claimedActive));
List<TaskFileJobEntity> claimed = service.claimRunnableJobs(10);
assertEquals(1, claimed.size(), "终态任务的 job 不入结果集");
assertEquals(22L, claimed.get(0).getId());
assertEquals(2, claimed.size(), "P1-13:终态任务的出表作业与活跃任务一样可认领");
assertEquals(21L, claimed.get(0).getId());
assertEquals(22L, claimed.get(1).getId());
@SuppressWarnings("unchecked")
ArgumentCaptor<LambdaUpdateWrapper<TaskFileJobEntity>> captor =
ArgumentCaptor.forClass(LambdaUpdateWrapper.class);
verify(taskFileJobMapper, times(2)).update(isNull(), captor.capture());
assertTrue(hasParam(captor.getAllValues().get(0), "FAILED"), "第一笔是终态收尾");
assertTrue(hasParam(captor.getAllValues().get(1), "RUNNING"), "第二笔才是正常 claim");
assertTrue(captor.getAllValues().get(0).getSqlSet().contains("terminal_callback_at"),
"终态作业必须留给兜底扫描,不能提前打终态回调");
assertTrue(hasParam(captor.getAllValues().get(0), "RUNNING"), "终态任务的 job 也要正常 claim");
assertTrue(hasParam(captor.getAllValues().get(1), "RUNNING"));
assertFalse(hasParam(captor.getAllValues().get(0), "FAILED"), "不得再把终态任务的 job 判死");
}
@Test
@@ -425,7 +425,7 @@ class TaskResultFileJobWorkerStuckScanTest {
worker.finishAfterExecution(job, new java.util.concurrent.atomic.AtomicBoolean(true));
verify(taskFileJobService).markFailedPermanentAwaitingFallback(job, "父任务已终态,结果作业不再执行");
verify(taskFileJobService).markFailedPermanentAwaitingFallback(job, "父任务已终态且本次执行未产出结果文件");
}
/**
@@ -0,0 +1,111 @@
package com.nanri.aiimage.modules.tutorial.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.modules.file.service.LocalFileStorageService;
import com.nanri.aiimage.modules.file.service.oss.OssStorageService;
import com.nanri.aiimage.modules.tutorial.mapper.TutorialPackageMapper;
import com.nanri.aiimage.modules.tutorial.model.entity.TutorialPackageEntity;
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.mockito.ArgumentCaptor;
import org.springframework.test.util.ReflectionTestUtils;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
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.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 教程包「分片拼装件 → confirm 搬桶落库」的契约(CR 第二轮 P1-8,与版本包同批)。
*
* <p>服务端新重载与控制器接线都在,缺的是执行证据:幂等命中(同 fileName+version 重试只
* 返回既有行)、成功后临时件清理、缺件拒绝。任何一条破掉,重试会重复搬桶或临时件堆盘。
*/
class TutorialPackageServiceChunkConfirmTest {
private final TutorialPackageMapper tutorialPackageMapper = mock(TutorialPackageMapper.class);
private final OssStorageService ossStorageService = mock(OssStorageService.class);
private final LocalFileStorageService localFiles = mock(LocalFileStorageService.class);
@TempDir
Path tempDir;
@BeforeAll
static void initializeMybatisMetadata() {
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""), TutorialPackageEntity.class);
}
private TutorialPackageService service() {
TutorialPackageService service = new TutorialPackageService(tutorialPackageMapper, ossStorageService);
ReflectionTestUtils.setField(service, "localFileStorageService", localFiles);
return service;
}
@Test
void 分片确认搬桶落库且临时件清掉() throws Exception {
Path zip = writeZip("教程包.zip");
when(localFiles.findLocalSourceFile("chunk-abc")).thenReturn(zip.toFile());
when(tutorialPackageMapper.selectOne(any())).thenReturn(null);
when(tutorialPackageMapper.insert(any(TutorialPackageEntity.class))).thenReturn(1);
when(tutorialPackageMapper.selectById(any())).thenReturn(null);
service().confirmTutorialPackage("tutorial/direct.zip", "教程包.zip", "2026.10", "chunk-abc");
ArgumentCaptor<TutorialPackageEntity> captor = ArgumentCaptor.forClass(TutorialPackageEntity.class);
verify(tutorialPackageMapper).insert(captor.capture());
assertEquals("教程包.zip", captor.getValue().getFileName());
verify(ossStorageService).uploadTutorialPackage(any(), anyString());
assertFalse(Files.exists(zip), "确认成功后临时拼装件必须删掉");
}
@Test
void 同名同版重复确认命中幂等不重复搬桶() throws Exception {
Path zip = writeZip("教程包.zip");
when(localFiles.findLocalSourceFile("chunk-abc")).thenReturn(zip.toFile());
TutorialPackageEntity existing = new TutorialPackageEntity();
existing.setId(11L);
existing.setFileName("教程包.zip");
when(tutorialPackageMapper.selectOne(any())).thenReturn(existing);
service().confirmTutorialPackage("tutorial/direct.zip", "教程包.zip", "2026.10", "chunk-abc");
verify(ossStorageService, never()).uploadTutorialPackage(any(), anyString());
verify(tutorialPackageMapper, never()).insert(any(TutorialPackageEntity.class));
assertFalse(Files.exists(zip), "幂等命中也要把临时件清掉");
}
@Test
void 拼装件缺失必须拒绝且不落库() {
when(localFiles.findLocalSourceFile("chunk-gone")).thenReturn(null);
assertThrows(RuntimeException.class,
() -> service().confirmTutorialPackage("tutorial/direct.zip", "教程包.zip", "2026.10", "chunk-gone"));
verify(tutorialPackageMapper, never()).insert(any(TutorialPackageEntity.class));
}
/** P2-4 起 confirm 会读 zip 中央目录,测试夹具必须是真 zip。 */
private Path writeZip(String name) throws Exception {
Path file = tempDir.resolve(name);
try (ZipOutputStream out = new ZipOutputStream(Files.newOutputStream(file))) {
out.putNextEntry(new ZipEntry("readme.txt"));
out.write("package".getBytes(StandardCharsets.UTF_8));
out.closeEntry();
}
return file;
}
}