feat(phase-2): 京东采集任务域——建单/分片回传落库/判活接线

This commit is contained in:
2026-11-14 09:54:04 +08:00
parent a429191edd
commit 53e176ba7c
14 changed files with 1558 additions and 5 deletions
@@ -1,6 +1,5 @@
package com.nanri.aiimage.modules.jd;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import java.io.IOException;
@@ -25,7 +24,6 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
* <p>形态为源码绊线:读实现文件断言契约字面量在位。激活时实现类与 Mapper XML
* 已存在;键改名必须同轮改本判据并在蓝图 §5 登记。
*/
@Disabled("Pending Phase 2: JdResultIngestService 与 JdProductMapper.xml 落地后激活")
class JdIngestPayloadContractTest {
private static final Path JAVA_ROOT = Path.of("src", "main", "java", "com", "nanri", "aiimage");
@@ -0,0 +1,108 @@
package com.nanri.aiimage.modules.jd.service;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.modules.jd.model.dto.JdCollectTaskCreateRequest;
import com.nanri.aiimage.modules.jd.model.vo.JdCollectTaskVo;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.mapper.TaskScopeStateMapper;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskScopeStateEntity;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
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.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* v1.4 Phase 2 建单行为测试:AC-1 的拒绝分支点名 + 铁律 19 的「建单显式写 LOCAL」判据
* + 黄金测试钉死的「本模块建单不接 submitSecret 闸门」形状(服务里没有那一调用点,
* 由 TaskModuleCoverageTest 的源码扫描兜底)。
*/
@ExtendWith(MockitoExtension.class)
class JdCollectTaskServiceTest {
@Mock
private FileTaskMapper fileTaskMapper;
@Mock
private TaskScopeStateMapper taskScopeStateMapper;
@Spy
private ObjectMapper objectMapper = new ObjectMapper();
@InjectMocks
private JdCollectTaskService service;
private JdCollectTaskCreateRequest validRequest() {
JdCollectTaskCreateRequest request = new JdCollectTaskCreateRequest();
request.setUserId(7L);
request.setShopName("测试旗舰店");
request.setListTabs(List.of("ONSALE", "OFFSALE"));
request.setMaxProducts(0);
return request;
}
@Test
void 建单成功且通道显式写LOCAL() {
// MP insert 由 KeyGenerator 回填自增 id;mock 里用 Answer 复刻同一行为
when(fileTaskMapper.insert(any(FileTaskEntity.class))).thenAnswer(invocation -> {
invocation.getArgument(0, FileTaskEntity.class).setId(33890L);
return 1;
});
JdCollectTaskVo vo = service.createTask(validRequest(), "device-abc");
assertThat(vo.getTaskId()).isNotNull();
assertThat(vo.getTaskNo()).startsWith("JD_SHOP_COLLECT-");
assertThat(vo.getCollectChannel()).as("铁律 19:建单入口显式写通道,不依赖 defaultFor 兜底")
.isEqualTo("LOCAL");
ArgumentCaptor<FileTaskEntity> taskCaptor = ArgumentCaptor.forClass(FileTaskEntity.class);
verify(fileTaskMapper).insert(taskCaptor.capture());
FileTaskEntity task = taskCaptor.getValue();
assertThat(task.getModuleType()).isEqualTo("JD_SHOP_COLLECT");
assertThat(task.getStatus()).isEqualTo("PENDING");
assertThat(task.getUserId()).isEqualTo(7L);
assertThat(task.getRequestJson()).contains("测试旗舰店").contains("ONSALE");
ArgumentCaptor<TaskScopeStateEntity> scopeCaptor = ArgumentCaptor.forClass(TaskScopeStateEntity.class);
verify(taskScopeStateMapper).insert(scopeCaptor.capture());
assertThat(scopeCaptor.getValue().getScopeKey()).isEqualTo("jd:测试旗舰店");
assertThat(scopeCaptor.getValue().getStateJson()).contains("\"cursor\":{}");
}
@Test
void 未选店铺建单被拒并点名() {
JdCollectTaskCreateRequest request = validRequest();
request.setShopName(" ");
assertThatThrownBy(() -> service.createTask(request, null))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("请选择要采集的京东店铺");
}
@Test
void 未选Tab建单被拒并点名() {
JdCollectTaskCreateRequest request = validRequest();
request.setListTabs(List.of());
assertThatThrownBy(() -> service.createTask(request, null))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("请选择要采集的商品 Tab");
}
@Test
void 不识别的Tab建单被拒() {
JdCollectTaskCreateRequest request = validRequest();
request.setListTabs(List.of("ALL"));
assertThatThrownBy(() -> service.createTask(request, null))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("ONSALE/OFFSALE");
verify(fileTaskMapper, never()).insert(any(FileTaskEntity.class));
}
}
@@ -0,0 +1,319 @@
package com.nanri.aiimage.modules.jd.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.jd.mapper.JdProductMapper;
import com.nanri.aiimage.modules.jd.model.dto.JdCollectTaskCreateRequest;
import com.nanri.aiimage.modules.jd.model.dto.JdIngestChunkRequest;
import com.nanri.aiimage.modules.jd.model.entity.JdProductEntity;
import com.nanri.aiimage.modules.jd.model.vo.JdIngestChunkVo;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.mapper.TaskScopeStateMapper;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskScopeStateEntity;
import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDateTime;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
/**
* v1.4 Phase 2 回传落库行为测试(蓝图 §4 Phase 2 待激活清单:JdProductSyncServiceTest)。
*
* <p>覆盖蓝图点名的五条判据:覆盖幂等(同一批两次提交行数不增、无 delete)、
* synced_at 刷新由 XML UPDATE 段保证、归属读不出跳过且不回填默认 1(铁律 30)、
* 空 items 不清空既有行、游标合并写(缺件沿用前值,铁律 30 / B84-01);
* 另盖 isEnd 落 SUCCESS 与京麦登录态失效整单判死(铁律 31)。
* 夹具走生产接线 {@code submitChunk},不反射私有方法。
*/
@ExtendWith(MockitoExtension.class)
class JdProductSyncServiceTest {
private static final Long TASK_ID = 33890L;
private static final Long USER_ID = 7L;
private static final Long COMPANY_ID = 2L;
@Mock
private FileTaskMapper fileTaskMapper;
@Mock
private JdProductMapper jdProductMapper;
@Mock
private TaskScopeStateMapper taskScopeStateMapper;
@Mock
private AdminUserMapper adminUserMapper;
@Mock
private JdCollectTaskService collectTaskService;
@Mock
private JdStaleTaskService jdStaleTaskService;
@Mock
private TaskProgressSnapshotService taskProgressSnapshotService;
@Spy
private ObjectMapper objectMapper = new ObjectMapper();
@InjectMocks
private JdResultIngestService service;
@BeforeAll
static void initTableInfo() {
// MP 条件构造器在纯单测里必须先初始化实体 TableInfo(CollectDataCredentialFatalTest 同款)
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), FileTaskEntity.class);
}
// ---------- 夹具 ----------
private FileTaskEntity runningTask() {
FileTaskEntity task = new FileTaskEntity();
task.setId(TASK_ID);
task.setModuleType("JD_SHOP_COLLECT");
task.setStatus("RUNNING");
task.setUserId(USER_ID);
task.setRequestJson("{\"userId\":7,\"shopName\":\"测试旗舰店\",\"listTabs\":[\"ONSALE\"],\"maxProducts\":0}");
return task;
}
private AdminUserEntity owner(Long companyId) {
AdminUserEntity owner = new AdminUserEntity();
owner.setId(USER_ID);
owner.setCompanyId(companyId);
return owner;
}
private TaskScopeStateEntity scopeRow() {
TaskScopeStateEntity scope = new TaskScopeStateEntity();
scope.setId(1L);
scope.setTaskId(TASK_ID);
scope.setModuleType("JD_SHOP_COLLECT");
scope.setScopeKey("jd:测试旗舰店");
scope.setStateJson("{\"cursor\":{\"tab\":\"ONSALE\",\"page\":1},\"itemsReceived\":2,\"lastBatchId\":null}");
scope.setReceivedChunkCount(1);
return scope;
}
private JdCollectTaskCreateRequest createRequest() {
JdCollectTaskCreateRequest request = new JdCollectTaskCreateRequest();
request.setUserId(USER_ID);
request.setShopName("测试旗舰店");
request.setListTabs(List.of("ONSALE"));
return request;
}
private JdIngestChunkRequest.JdIngestItemDto item(String productCode, String title) {
JdIngestChunkRequest.JdIngestItemDto item = new JdIngestChunkRequest.JdIngestItemDto();
item.setProductCode(productCode);
Map<String, Object> summary = new LinkedHashMap<>();
summary.put("title", title);
summary.put("shopId", "shop-001");
summary.put("saleStatus", "上架中");
summary.put("stockTotal", 2400);
summary.put("jdCreatedAt", "2026-11-13 14:06:07");
summary.put("unknownFutureKey", "ignored");
item.setSummary(summary);
Map<String, Object> detail = new LinkedHashMap<>();
detail.put("商品属性", Map.of("key", "brand", "label", "品牌", "value", "花屿巷"));
detail.put("规格", 2);
item.setDetail(detail);
JdIngestChunkRequest.JdIngestImageDto image = new JdIngestChunkRequest.JdIngestImageDto();
image.setType("MAIN");
image.setObjectKey("jd-products/2/33890/abc.jpg");
item.setImages(List.of(image));
return item;
}
private JdIngestChunkRequest chunk(JdIngestChunkRequest.JdIngestItemDto... items) {
JdIngestChunkRequest request = new JdIngestChunkRequest();
request.setBatchId("JD20261114-0001");
Map<String, Object> cursor = new LinkedHashMap<>();
cursor.put("tab", "ONSALE");
cursor.put("page", 2);
request.setCursor(cursor);
request.setItems(List.of(items));
return request;
}
private void stubHappyPath() {
lenient().when(fileTaskMapper.selectById(TASK_ID)).thenReturn(runningTask());
lenient().when(adminUserMapper.selectById(USER_ID)).thenReturn(owner(COMPANY_ID));
lenient().when(collectTaskService.readCreateRequest(any(FileTaskEntity.class))).thenReturn(createRequest());
lenient().when(collectTaskService.findScopeRow(TASK_ID)).thenReturn(scopeRow());
}
// ---------- 判据 ----------
@Test
void 正常回传按归属落库且不回填默认1() {
stubHappyPath();
JdIngestChunkVo vo = service.submitChunk(TASK_ID,
chunk(item("10036442942137", "艺考形体服女"), item("10036442942138", "艺考形体服男")));
assertThat(vo.isAccept()).isTrue();
assertThat(vo.getUpserted()).isEqualTo(2);
assertThat(vo.getImagesRegistered()).isZero();
@SuppressWarnings("unchecked")
ArgumentCaptor<List<JdProductEntity>> captor = ArgumentCaptor.forClass((Class) List.class);
verify(jdProductMapper).upsertBatch(captor.capture());
List<JdProductEntity> rows = captor.getValue();
assertThat(rows).hasSize(2);
JdProductEntity first = rows.get(0);
assertThat(first.getCompanyId()).as("归属物化按 owner 的 company_id,不回填默认 1(铁律 30)").isEqualTo(COMPANY_ID);
assertThat(first.getUserId()).isEqualTo(USER_ID);
assertThat(first.getTaskId()).isEqualTo(TASK_ID);
assertThat(first.getShopId()).isEqualTo("shop-001");
assertThat(first.getShopName()).isEqualTo("测试旗舰店");
assertThat(first.getJdCreatedAt()).isEqualTo(LocalDateTime.of(2026, 11, 13, 14, 6, 7));
assertThat(first.getAttrCount()).as("detail 键数进 attr_count").isEqualTo(2);
assertThat(first.getAttrJson()).as("detail 原样透传,不裁剪").contains("品牌").contains("花屿巷");
assertThat(first.getCollectBatchId()).isEqualTo("JD20261114-0001");
assertThat(first.getImageCount()).isZero().as("Phase 2 图片只记 tempKey 待位");
}
@Test
void 同一批两次提交行数不增且无delete() {
stubHappyPath();
JdIngestChunkRequest request = chunk(item("10036442942137", "艺考形体服女"));
service.submitChunk(TASK_ID, request);
service.submitChunk(TASK_ID, request);
verify(jdProductMapper, times(2)).upsertBatch(anyList());
verify(jdProductMapper, never()).delete(any(Wrapper.class));
verify(jdProductMapper, never()).deleteById(any(java.io.Serializable.class));
// 两批进 upsert 的行同键同形(uk_company_shop_code 覆盖最新,AC-5 行数不增)
@SuppressWarnings("unchecked")
ArgumentCaptor<List<JdProductEntity>> captor = ArgumentCaptor.forClass((Class) List.class);
verify(jdProductMapper, times(2)).upsertBatch(captor.capture());
List<List<JdProductEntity>> bothBatches = captor.getAllValues();
assertThat(bothBatches.get(0)).hasSameSizeAs(bothBatches.get(1));
assertThat(bothBatches.get(0).get(0).getProductCode())
.as("同一商品重复回传仍是同一唯一键行(覆盖最新)")
.isEqualTo(bothBatches.get(1).get(0).getProductCode());
}
@Test
void 二次采集synced_at刷新由XML更新段保证() throws Exception {
stubHappyPath();
// 二次采集命中的是 upsert 的 UPDATE 分支:XML 显式刷 synced_at = CURRENT_TIMESTAMP
//(INSERT 段走列默认值),这条断言钉住刷新语义不被静默删掉。
String xml = Files.readString(Path.of("src/main/resources/mapper/jd/JdProductMapper.xml"));
assertThat(xml).contains("synced_at = CURRENT_TIMESTAMP");
service.submitChunk(TASK_ID, chunk(item("10036442942137", "艺考形体服女")));
service.submitChunk(TASK_ID, chunk(item("10036442942137", "艺考形体服女")));
verify(jdProductMapper, times(2)).upsertBatch(anyList());
}
@Test
void 归属读不出跳过落库且回执拒绝() {
lenient().when(fileTaskMapper.selectById(TASK_ID)).thenReturn(runningTask());
lenient().when(adminUserMapper.selectById(USER_ID)).thenReturn(owner(null));
JdIngestChunkVo vo = service.submitChunk(TASK_ID, chunk(item("10036442942137", "艺考形体服女")));
assertThat(vo.isAccept()).isFalse();
assertThat(vo.getMessage()).contains("归属");
verify(jdProductMapper, never()).upsertBatch(anyList());
}
@Test
void 空items不清空既有行且游标沿用前值() {
stubHappyPath();
JdIngestChunkRequest request = chunk();
request.setItems(List.of());
request.setCursor(null);
JdIngestChunkVo vo = service.submitChunk(TASK_ID, request);
assertThat(vo.isAccept()).isTrue();
assertThat(vo.getUpserted()).isZero();
verify(jdProductMapper, never()).upsertBatch(anyList());
ArgumentCaptor<TaskScopeStateEntity> scopeCaptor = ArgumentCaptor.forClass(TaskScopeStateEntity.class);
verify(taskScopeStateMapper).updateById(scopeCaptor.capture());
assertThat(scopeCaptor.getValue().getStateJson())
.contains("\"page\":1")
.as("没带 cursor 的请求不得把既有游标抹掉(铁律 30 / B84-01)");
}
@Test
void 游标合并写_缺件沿用前值_同键以本次为准_嵌套递归() {
Map<String, Object> previous = new LinkedHashMap<>();
previous.put("tab", "ONSALE");
previous.put("page", 1);
previous.put("detailDone", 120);
// 本次没带 cursor = 沿用前值,不是"没有"
assertThat(JdResultIngestService.mergeCursor(previous, null))
.containsEntry("page", 1).containsEntry("detailDone", 120);
// 带了按键合并:同键以本次为准,没带的键保留前值,null 值视为没带
Map<String, Object> incoming = new LinkedHashMap<>();
incoming.put("page", 3);
incoming.put("note", null);
assertThat(JdResultIngestService.mergeCursor(previous, incoming))
.containsEntry("page", 3).containsEntry("detailDone", 120).doesNotContainKey("note");
// 嵌套 Map 递归合并
Map<String, Object> prevNested = Map.of("cursor", Map.of("tab", "ONSALE"));
Map<String, Object> inNested = Map.of("cursor", Map.of("page", 5));
assertThat(JdResultIngestService.mergeCursor(prevNested, inNested))
.containsEntry("cursor", Map.of("tab", "ONSALE", "page", 5));
}
@Test
void isEnd为真任务落SUCCESS() {
stubHappyPath();
// CAS 置位成功(mock 默认返 0,这里复刻条件 UPDATE 命中 1 行)
when(fileTaskMapper.update(isNull(), any(LambdaUpdateWrapper.class))).thenReturn(1);
JdIngestChunkRequest request = chunk(item("10036442942137", "艺考形体服女"));
request.setIsEnd(true);
service.submitChunk(TASK_ID, request);
verify(fileTaskMapper).update(isNull(), any(LambdaUpdateWrapper.class));
verify(taskProgressSnapshotService).markTerminal(eq(TASK_ID), eq("JD_SHOP_COLLECT"), eq("SUCCESS"), anyString());
}
@Test
void 京麦登录态失效整单落FAILED且不落库() {
lenient().when(fileTaskMapper.selectById(TASK_ID)).thenReturn(runningTask());
lenient().when(jdStaleTaskService.terminalizeOnJdLoginFatal(any(FileTaskEntity.class), anyString()))
.thenReturn(true);
JdIngestChunkRequest request = new JdIngestChunkRequest();
request.setBatchId("JD20261114-0002");
request.setError("京麦未登录,请重新登录");
JdIngestChunkVo vo = service.submitChunk(TASK_ID, request);
assertThat(vo.isAccept()).isFalse();
assertThat(vo.getMessage()).contains("京麦");
verify(jdProductMapper, never()).upsertBatch(anyList());
verify(jdStaleTaskService).terminalizeOnJdLoginFatal(any(FileTaskEntity.class), anyString());
}
}
@@ -0,0 +1,123 @@
package com.nanri.aiimage.modules.jd.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.service.DistributedJobLockService;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.service.StaleTaskHeartbeatPolicy;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatLivenessService;
import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;
import java.time.LocalDateTime;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* v1.4 Phase 2 判活行为测试:京麦登录态失效判死(铁律 31,AC-10 文案口径)+
* 心跳超时兜底判死的调度入口(分布式锁被占时直接跳过——A/B 双实例单跑契约)。
* CAS 落终态用 {@code fileTaskMapper.update} 返回值驱动,不反射私有方法。
*/
@ExtendWith(MockitoExtension.class)
class JdStaleTaskServiceTest {
@Mock
private FileTaskMapper fileTaskMapper;
@Mock
private TaskDistributedLockService taskDistributedLockService;
@Mock
private DistributedJobLockService distributedJobLockService;
@Spy
private StaleTaskHeartbeatPolicy staleTaskHeartbeatPolicy =
new StaleTaskHeartbeatPolicy(mock(TaskHeartbeatLivenessService.class));
@Mock
private TaskProgressSnapshotService taskProgressSnapshotService;
@InjectMocks
private JdStaleTaskService service;
@BeforeAll
static void initTableInfo() {
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), FileTaskEntity.class);
}
private FileTaskEntity runningTask() {
FileTaskEntity task = new FileTaskEntity();
task.setId(33890L);
task.setModuleType("JD_SHOP_COLLECT");
task.setStatus("RUNNING");
task.setUserId(7L);
task.setUpdatedAt(LocalDateTime.now().minusHours(2));
return task;
}
@Test
void 京麦登录态词表只认京麦这一族() {
assertThat(JdStaleTaskService.isJdLoginStateFailure("京麦未登录,请重新登录")).isTrue();
assertThat(JdStaleTaskService.isJdLoginStateFailure("店铺登录态失效")).isTrue();
assertThat(JdStaleTaskService.isJdLoginStateFailure("channel_busy")).isFalse();
assertThat(JdStaleTaskService.isJdLoginStateFailure("LLM 余额不足")).isFalse();
assertThat(JdStaleTaskService.isJdLoginStateFailure(null)).isFalse();
assertThat(JdStaleTaskService.isJdLoginStateFailure(" ")).isFalse();
}
@Test
void 终态文案点名京麦并给动作句() {
String withPhrase = JdStaleTaskService.terminalLoginMessage("京麦未登录,无法打开商品列表");
assertThat(withPhrase).contains("京麦未登录").contains("登录态失效").contains("重新登录京麦");
assertThat(withPhrase).doesNotContain("稍后重试");
// 原文缺判据词时两句判据词仍然点名(AC-10 的文案口径:error_message 含「京麦未登录 / 登录态失效」)
String withoutPhrase = JdStaleTaskService.terminalLoginMessage("Cookie 已过期");
assertThat(withoutPhrase).contains("Cookie 已过期").contains("京麦未登录").contains("登录态失效");
}
@Test
void 登录态失效CAS落终态并同步进度快照() {
FileTaskEntity task = runningTask();
when(fileTaskMapper.update(isNull(), any(LambdaUpdateWrapper.class))).thenReturn(1);
boolean closed = service.terminalizeOnJdLoginFatal(task, "京麦未登录,请重新登录");
assertThat(closed).isTrue();
verify(taskProgressSnapshotService).markTerminal(eq(33890L), eq("JD_SHOP_COLLECT"), eq("FAILED"), anyString());
}
@Test
void 已终态或CAS不命中时不重复判死() {
FileTaskEntity task = runningTask();
when(fileTaskMapper.update(isNull(), any(LambdaUpdateWrapper.class))).thenReturn(0);
boolean closed = service.terminalizeOnJdLoginFatal(task, "京麦未登录");
assertThat(closed).isFalse();
verify(taskProgressSnapshotService, never()).markTerminal(any(), anyString(), anyString(), anyString());
}
@Test
void 分布式锁被占时本轮直接跳过() {
when(distributedJobLockService.tryLock(anyString(), any())).thenReturn(null);
service.finalizeStaleTasks();
verify(fileTaskMapper, never()).selectList(any());
}
}