super/crawler-plugin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(上架): 店铺互斥改为按(设备,店铺)，同店可在不同客户端并行跑不同国家

Browse Source 
背景：紫鸟浏览器会话是每台客户端一份，同一家店可以在两台机器上并行；
国家是会话内的可切换状态（SwitchingCountries，断线重连还会再切），
所以真正必须串行的只有"同一台设备上的同一家店"。原来的全局按店铺互斥
把跨机器的合法并行也挡了（2026-09-18 任务 28624 被 28616 误挡）。

- V130：biz_publish_file 增加 device_id 列
- AdminAuthSupport.currentDeviceId()：只读 JWT 签名的 deviceId claim，
  不信任客户端可控的 X-Device-Id 请求头
- activateFile 互斥键改为 (device_id, shop_name)；device 为空（旧客户端
  token 无该 claim / 内部令牌调用）时退回全局店铺互斥，保守不放宽；
  存量 RUNNING 行的 NULL device 视为"来源不明"，同样保守拦到跑完为止
- 前端与客户端无需改动：页面 axios 对 /newApi 已带 Authorization Bearer
This commit is contained in:
黄自达
2026-09-18 16:08:08 +08:00
parent 9d39705c77
commit e0303f9cba
7 changed files with 214 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend-java/src/main/java/com/nanri/aiimage/common/security/AdminAuthSupport.java
+26 -2
View File
@@ -9,6 +9,7 @@ import io.jsonwebtoken.Claims;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Component;
@@ -19,6 +20,7 @@ import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
@Slf4j
@Component
@RequiredArgsConstructor
public class AdminAuthSupport {
@@ -62,8 +64,30 @@ public class AdminAuthSupport {
return user;
}
/** 当前用户必须是管理员或超级管理员，否则抛 403。 */
public AdminUserEntity requireAdmin(HttpServletRequest request) {
/**
* 解析当前请求 JWT 中**签名的**设备标识（deviceId claim）；识别不出时返回空串。
*
* <p>无 token、token 过期/非法、内部令牌通道调用一律返回空串——调用方必须把空串
* 当作"来源不明"做保守判定，绝不据此放宽任何限制。只认签名 claim，不接受
* X-Device-Id 请求头（头由客户端可控，见 {@link DeviceSessionPolicy} 类注释）。</p>
*
* <p>本方法只做识别、不做鉴权，因此解析失败不抛异常，仅记日志后返回空串，
* 避免把匿名/内部调用直接升级成 401。</p>
*/
public String currentDeviceId(HttpServletRequest request) {
String token = resolveToken(request);
if (token == null || token.isBlank()) {
return "";
}
try {
return DeviceSessionPolicy.claimDeviceId(jwtService.parse(token));
} catch (Exception ex) {
log.warn("[auth] 解析 token 取设备标识失败，按来源不明处理: {}", ex.getMessage());
return "";
}
}
/** 当前用户必须是管理员或超级管理员，否则抛 403。 */ public AdminUserEntity requireAdmin(HttpServletRequest request) {
AdminUserEntity user = requireUser(request);
String role = currentRole(user);
if (role == null) {
backend-java/src/main/java/com/nanri/aiimage/modules/publish/controller/PublishController.java
+9 -3
View File
@@ -1,6 +1,7 @@
package com.nanri.aiimage.modules.publish.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.publish.model.dto.PublishParseRequest;
import com.nanri.aiimage.modules.publish.model.dto.PublishSubmitResultRequest;
import com.nanri.aiimage.modules.publish.model.dto.PublishTaskBatchRequest;
@@ -14,6 +15,7 @@ import com.nanri.aiimage.modules.publish.service.PublishTaskService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.DeleteMapping;
@@ -34,6 +36,7 @@ import com.nanri.aiimage.modules.task.model.vo.TaskProgressLightBatchVo;
public class PublishController {
private final PublishTaskService publishTaskService;
private final AdminAuthSupport adminAuthSupport;
@PostMapping("/parse")
@Operation(
@@ -57,15 +60,18 @@ public class PublishController {
@PostMapping("/tasks/{taskId}/files/{fileId}/activate")
@Operation(
summary = "激活任务中的单个文件",
description = "前端派发 Python 队列前调用。taskId 和 fileId 用于定位文件，user_id 可省略；如传入则校验任务归属。同一任务同一时间只允许一个 RUNNING 文件；重复激活当前 RUNNING 文件为幂等操作。")
description = "前端派发 Python 队列前调用。taskId 和 fileId 用于定位文件，user_id 可省略；如传入则校验任务归属。同一任务同一时间只允许一个 RUNNING 文件；重复激活当前 RUNNING 文件为幂等操作。"
+ "店铺互斥按 (发起方设备, 店铺) 判定：同一台机器上同一店铺只允许一个任务在跑（该机器上该店铺只有一个紫鸟浏览器会话，并发会互相切换国家）；不同设备各自持有独立会话，允许同一店铺并行跑不同国家。"
+ "设备号取自 JWT 签名的 deviceId claim，缺失时退回按店铺全局互斥。")
public ApiResponse<Void> activateFile(
@Parameter(description = "上架任务 ID", required = true, example = "9001")
@PathVariable Long taskId,
@Parameter(description = "任务内文件 ID", required = true, example = "9101")
@PathVariable Long fileId,
@Parameter(description = "可选的任务所属用户 ID；省略时由 taskId 反查", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId) {
publishTaskService.activateFile(taskId, fileId, userId);
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest request) {
publishTaskService.activateFile(taskId, fileId, userId, adminAuthSupport.currentDeviceId(request));
return ApiResponse.success(null);
}
backend-java/src/main/java/com/nanri/aiimage/modules/publish/model/entity/PublishFileEntity.java
+2
View File
@@ -20,6 +20,8 @@ public class PublishFileEntity {
private Integer matched;
private String shopId;
private Long matchedUserId;
/** 激活该文件时客户端所在设备（JWT 签名的 deviceId）；空表示来源不明，按全局店铺互斥保守处理。 */
private String deviceId;
private String platform;
private String companyName;
private String matchStatus;
backend-java/src/main/java/com/nanri/aiimage/modules/publish/service/PublishTaskService.java
+43 -12
View File
@@ -174,7 +174,14 @@ public class PublishTaskService {
}
}
public void activateFile(Long taskId, Long fileId, Long userId) {
/**
* 激活任务中的单个文件。
*
* @param deviceId 发起方设备标识（JWT 签名的 deviceId claim）；空串/空白表示来源不明
* （旧客户端 token 无该 claim、内部令牌调用），此时退回全局店铺互斥
*/
public void activateFile(Long taskId, Long fileId, Long userId, String deviceId) {
String device = deviceId == null ? "" : deviceId.trim();
try (TaskDistributedLockService.LockHandle lock =
taskDistributedLockService.acquire(MODULE_TYPE, taskId)) {
if (lock == null) {
@@ -198,23 +205,45 @@ public class PublishTaskService {
if (runningFile != null) {
throw new BusinessException("同一任务已有文件正在执行: " + runningFile.getSourceFilename());
}
// 店铺级互斥：同一店铺同一时刻只允许一个上架任务在跑。
// 2026-09-17 事故（28519/28520/28521 相继提交同一店铺「林洪武」）：同一店铺被多个
// 任务并发打开，客户端 startBrowser 全部返回 -10000，三个任务一起失败。激活是任务
// 真正开跑的唯一入口，在这里挡掉并带出占用中的任务号，用户才知道要等谁。
// 店铺级互斥：同一台设备上同一店铺同一时刻只允许一个上架任务在跑。
// 2026-09-17 事故（28519/28520/28521 相继提交同一店铺「林洪武」）：同一台机器上同一
// 店铺被多个任务并发打开，客户端 startBrowser 全部返回 -10000，三个任务一起失败。
// 激活是任务真正开跑的唯一入口，在这里挡掉并带出占用中的任务号，用户才知道要等谁。
//
// 互斥键是 (设备, 店铺) 而不是店铺：紫鸟浏览器会话是**每台机器一份**，不同客户端
// 各自持有独立会话，同一家店可以在两台机器上并行跑不同国家（2026-09-18 任务 28624
// 在另一台机器上被 28616 误挡）。真正必须串行的是同一台设备——那里只有一个会话，
// 两个任务会互相切换国家（add_product.py 的 SwitchingCountries 是会话级状态，任务
// 中途断线重连还会再切一次），轻则失败，重则把 A 国家的商品提交进 B 国家的店铺。
// 设备号取自 JWT 签名的 deviceId claim；为空（旧客户端 token 无该 claim / 内部令牌
// 调用）时退回改动前的全局店铺互斥，保守不放宽。
//
// 注意：本校验与随后的状态更新之间仍有极小竞态窗口（两个请求恰好同时通过校验）；
// 真正的串行由客户端店铺锁保证，这一层的目的是尽早给出明确提示，避免白传文件与重复执行。
String shopName = file.getShopName();
if (shopName != null && !shopName.isBlank()) {
PublishFileEntity shopRunning = publishFileMapper.selectOne(
new LambdaQueryWrapper<PublishFileEntity>()
.eq(PublishFileEntity::getShopName, shopName)
.eq(PublishFileEntity::getStatus, STATUS_RUNNING)
.ne(PublishFileEntity::getTaskId, taskId)
.orderByAsc(PublishFileEntity::getId)
.last("limit 1"));
LambdaQueryWrapper<PublishFileEntity> shopRunningQuery = new LambdaQueryWrapper<PublishFileEntity>()
.eq(PublishFileEntity::getShopName, shopName)
.eq(PublishFileEntity::getStatus, STATUS_RUNNING)
.ne(PublishFileEntity::getTaskId, taskId)
.orderByAsc(PublishFileEntity::getId)
.last("limit 1");
if (device.isEmpty()) {
log.info("[publish] 激活无设备标识，按全局店铺互斥判定 taskId={} fileId={} shop={}",
taskId, fileId, shopName);
} else {
// 本设备的 RUNNING 行，以及设备未知的存量行（旧客户端/内部调用，NULL 或空串）
// ——后者无法判断落在哪台机器上，一律保守视为可能同机。
shopRunningQuery.and(wrapper -> wrapper
.eq(PublishFileEntity::getDeviceId, device)
.or().isNull(PublishFileEntity::getDeviceId)
.or().eq(PublishFileEntity::getDeviceId, ""));
}
PublishFileEntity shopRunning = publishFileMapper.selectOne(shopRunningQuery);
if (shopRunning != null) {
log.warn("[publish] 店铺互斥拦截 taskId={} fileId={} shop={} device={} 占用任务={} 占用设备={}",
taskId, fileId, shopName, device,
shopRunning.getTaskId(), shopRunning.getDeviceId());
throw new BusinessException("店铺「" + shopName + "」已有上架任务正在执行（任务 "
+ shopRunning.getTaskId() + "），请等它完成后再提交");
}
@@ -224,11 +253,13 @@ public class PublishTaskService {
.eq(PublishFileEntity::getTaskId, taskId)
.eq(PublishFileEntity::getStatus, STATUS_PENDING)
.set(PublishFileEntity::getStatus, STATUS_RUNNING)
.set(PublishFileEntity::getDeviceId, device.isEmpty() ? null : device)
.set(PublishFileEntity::getUpdatedAt, LocalDateTime.now())
.set(PublishFileEntity::getErrorMessage, null));
if (updated <= 0) {
throw new BusinessException("文件激活失败，请刷新后重试");
}
log.info("[publish] 文件激活成功 taskId={} fileId={} shop={} device={}", taskId, fileId, shopName, device);
if (STATUS_PENDING.equals(task.getStatus())) {
fileTaskMapper.update(null, new LambdaUpdateWrapper<FileTaskEntity>()
.eq(FileTaskEntity::getId, taskId)
backend-java/src/main/resources/db/V130__publish_file_device_id.sql
+33
View File
@@ -0,0 +1,33 @@
-- V130: biz_publish_file 增加 device_id 列（激活该文件时客户端所在设备）
--
-- 背景：同店铺互斥原本只按 shop_name 全局判定（PublishTaskService.activateFile）。
-- 但紫鸟浏览器会话是**每台机器一份**：不同客户端各自持有独立的店铺会话，同一家店
-- 完全可以在两台机器上并行跑不同国家。原来的全局判定把这种合法的跨机器并行也挡了
-- （2026-09-18 任务 28624 被 28616 误挡：两条在不同机器上）。
-- 真正必须串行的是「同一台机器上的同一家店」——那里只有一个浏览器会话，两个任务会
-- 互相切换国家（add_product.py 的 SwitchingCountries 是会话级状态，任务中途断线重连
-- 还会再切一次），轻则失败，重则把 A 国家的商品提交进 B 国家的店铺。
--
-- 因此互斥键由 shop_name 改为 (device_id, shop_name)。device 取自 JWT 里**签名的**
-- deviceId claim（绝不使用客户端可控的 X-Device-Id 请求头，见 DeviceSessionPolicy 注释）。
--
-- 空值语义：NULL/空串表示"来源不明"——旧客户端（未升级、token 无 claim）或内部令牌调用。
-- 该情形退回改动前的全局店铺互斥，保持保守，不因迁移把风险放开。存量 RUNNING 行均为 NULL，
-- 因此会继续全挡直到跑完，随后新激活的行都带设备号，跨机器并行自然生效。
--
-- 风险：ADD COLUMN 走 INSTANT/INPLACE，生产该表仅数百行，秒级完成；建议低峰执行。
-- 回滚：ALTER TABLE biz_publish_file DROP COLUMN device_id;
SET @db_name = DATABASE();
SET @col_exists := (
SELECT COUNT(*) FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = @db_name AND TABLE_NAME = 'biz_publish_file' AND COLUMN_NAME = 'device_id'
);
SET @sql := IF(@col_exists = 0,
'ALTER TABLE biz_publish_file ADD COLUMN device_id VARCHAR(128) NULL COMMENT ''device that activated this file, from signed JWT deviceId claim'' AFTER matched_user_id',
'SELECT 1'
);
PREPARE stmt FROM @sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
backend-java/src/test/java/com/nanri/aiimage/modules/publish/service/PublishTaskServiceTest.java
+98 -8
View File
@@ -37,6 +37,7 @@ import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
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;
@@ -109,6 +110,10 @@ class PublishTaskServiceTest {
@InjectMocks private PublishTaskService service;
/** 店铺互斥按 (设备, 店铺) 判定：两台机器各自的设备标识。 */
private static final String DEVICE_A = "device-aaaa";
private static final String DEVICE_B = "device-bbbb";
private final List<TaskChunkEntity> storedChunks = new ArrayList<>();
private final List<TaskScopeStateEntity> storedScopes = new ArrayList<>();
private final Map<String, String> rustfsPayloads = new LinkedHashMap<>();
@@ -744,7 +749,7 @@ class PublishTaskServiceTest {
when(publishFileMapper.selectOne(any())).thenReturn(running);
BusinessException error = assertThrows(BusinessException.class,
() -> service.activateFile(taskId, fileId, 7L));
() -> service.activateFile(taskId, fileId, 7L, DEVICE_A));
assertTrue(error.getMessage().contains("已有文件正在执行"));
verify(publishFileMapper, never()).update(isNull(), any());
@@ -752,25 +757,26 @@ class PublishTaskServiceTest {
}
@Test
void activateFileRejectsShopAlreadyRunningInAnotherTask() {
void activateFileRejectsShopAlreadyRunningOnSameDevice() {
long taskId = 106L;
long fileId = 206L;
FileTaskEntity task = task(taskId, 7L, "RUNNING");
PublishFileEntity target = file(taskId, fileId, "PENDING", "林洪武.xlsx");
target.setShopName("林洪武");
// 另一个任务（28520）正跑同一店铺 —— 2026-09-17 事故形态
// 同一台设备上另一个任务（28520）正跑同一店铺 —— 2026-09-17 事故形态
PublishFileEntity otherTaskRunning = file(105L, 205L, "RUNNING", "林洪武.xlsx");
otherTaskRunning.setShopName("林洪武");
otherTaskRunning.setDeviceId(DEVICE_A);
TaskDistributedLockService.LockHandle lock = mock(TaskDistributedLockService.LockHandle.class);
when(taskDistributedLockService.acquire(PublishTaskService.MODULE_TYPE, taskId)).thenReturn(lock);
when(fileTaskMapper.selectById(taskId)).thenReturn(task);
when(publishFileMapper.selectById(fileId)).thenReturn(target);
// 第一次 selectOne：同任务其它 RUNNING 文件（无）；第二次：同店铺跨任务（有）
// 第一次 selectOne：同任务其它 RUNNING 文件（无）；第二次：同设备同店铺跨任务（有）
when(publishFileMapper.selectOne(any())).thenReturn(null, otherTaskRunning);
BusinessException error = assertThrows(BusinessException.class,
() -> service.activateFile(taskId, fileId, 7L));
() -> service.activateFile(taskId, fileId, 7L, DEVICE_A));
assertTrue(error.getMessage().contains("林洪武"), "提示要带店铺名: " + error.getMessage());
assertTrue(error.getMessage().contains("105"), "提示要带占用中的任务号: " + error.getMessage());
@@ -778,6 +784,90 @@ class PublishTaskServiceTest {
verify(lock).close();
}
/** 用户需求：同一家店允许在不同客户端（不同机器）上并行跑不同国家。 */
@Test
void activateFileAllowsShopRunningOnAnotherDevice() {
long taskId = 109L;
long fileId = 209L;
FileTaskEntity task = task(taskId, 7L, "RUNNING");
PublishFileEntity target = file(taskId, fileId, "PENDING", "林芳.xlsx");
target.setShopName("林芳");
TaskDistributedLockService.LockHandle lock = mock(TaskDistributedLockService.LockHandle.class);
when(taskDistributedLockService.acquire(PublishTaskService.MODULE_TYPE, taskId)).thenReturn(lock);
when(fileTaskMapper.selectById(taskId)).thenReturn(task);
when(publishFileMapper.selectById(fileId)).thenReturn(target);
// 另一台设备的占用行不会命中本设备的查询，因此这里返回 null
when(publishFileMapper.selectOne(any())).thenReturn(null);
when(publishFileMapper.update(isNull(), any())).thenReturn(1);
service.activateFile(taskId, fileId, 7L, DEVICE_B);
verify(publishFileMapper).update(isNull(), any());
// 店铺互斥查询必须真正带上设备维度，否则跨机器并行会被重新挡住
ArgumentCaptor<LambdaQueryWrapper> captor = ArgumentCaptor.forClass(LambdaQueryWrapper.class);
verify(publishFileMapper, times(2)).selectOne(captor.capture());
String shopSql = captor.getAllValues().get(1).getSqlSegment();
assertTrue(shopSql.contains("device_id"), "店铺互斥查询要带设备维度: " + shopSql);
assertTrue(shopSql.contains("shop_name"), "设备维度不能替代店铺维度: " + shopSql);
}
/** 存量行（改动前激活、device_id 为空）无法判断落在哪台机器上，一律保守视为可能同机。 */
@Test
void activateFileRejectsWhenRunningRowHasUnknownDevice() {
long taskId = 110L;
long fileId = 210L;
FileTaskEntity task = task(taskId, 7L, "RUNNING");
PublishFileEntity target = file(taskId, fileId, "PENDING", "林芳.xlsx");
target.setShopName("林芳");
PublishFileEntity legacyRunning = file(105L, 205L, "RUNNING", "林芳.xlsx");
legacyRunning.setShopName("林芳");
legacyRunning.setDeviceId(null);
TaskDistributedLockService.LockHandle lock = mock(TaskDistributedLockService.LockHandle.class);
when(taskDistributedLockService.acquire(PublishTaskService.MODULE_TYPE, taskId)).thenReturn(lock);
when(fileTaskMapper.selectById(taskId)).thenReturn(task);
when(publishFileMapper.selectById(fileId)).thenReturn(target);
when(publishFileMapper.selectOne(any())).thenReturn(null, legacyRunning);
BusinessException error = assertThrows(BusinessException.class,
() -> service.activateFile(taskId, fileId, 7L, DEVICE_B));
assertTrue(error.getMessage().contains("105"), "存量未知设备行必须继续拦住: " + error.getMessage());
verify(publishFileMapper, never()).update(isNull(), any());
verify(lock).close();
}
/** 无设备标识（旧客户端 token 无 deviceId claim / 内部令牌调用）→ 退回改动前的全局店铺互斥。 */
@Test
void activateFileFallsBackToGlobalShopCheckWhenDeviceMissing() {
long taskId = 111L;
long fileId = 211L;
FileTaskEntity task = task(taskId, 7L, "RUNNING");
PublishFileEntity target = file(taskId, fileId, "PENDING", "林芳.xlsx");
target.setShopName("林芳");
PublishFileEntity otherDeviceRunning = file(105L, 205L, "RUNNING", "林芳.xlsx");
otherDeviceRunning.setShopName("林芳");
otherDeviceRunning.setDeviceId(DEVICE_A);
TaskDistributedLockService.LockHandle lock = mock(TaskDistributedLockService.LockHandle.class);
when(taskDistributedLockService.acquire(PublishTaskService.MODULE_TYPE, taskId)).thenReturn(lock);
when(fileTaskMapper.selectById(taskId)).thenReturn(task);
when(publishFileMapper.selectById(fileId)).thenReturn(target);
when(publishFileMapper.selectOne(any())).thenReturn(null, otherDeviceRunning);
BusinessException error = assertThrows(BusinessException.class,
() -> service.activateFile(taskId, fileId, 7L, ""));
assertTrue(error.getMessage().contains("105"), "来源不明时必须保持全局互斥: " + error.getMessage());
ArgumentCaptor<LambdaQueryWrapper> captor = ArgumentCaptor.forClass(LambdaQueryWrapper.class);
verify(publishFileMapper, times(2)).selectOne(captor.capture());
assertFalse(captor.getAllValues().get(1).getSqlSegment().contains("device_id"),
"来源不明时不应按设备收窄，否则等于放宽互斥");
verify(publishFileMapper, never()).update(isNull(), any());
verify(lock).close();
}
@Test
void activateFileAllowsWhenShopHasNoOtherRunningTask() {
long taskId = 107L;
@@ -793,7 +883,7 @@ class PublishTaskServiceTest {
when(publishFileMapper.selectOne(any())).thenReturn(null);
when(publishFileMapper.update(isNull(), any())).thenReturn(1);
service.activateFile(taskId, fileId, 7L);
service.activateFile(taskId, fileId, 7L, DEVICE_A);
verify(publishFileMapper).update(isNull(), any());
}
@@ -813,7 +903,7 @@ class PublishTaskServiceTest {
when(publishFileMapper.selectOne(any())).thenReturn(null);
when(publishFileMapper.update(isNull(), any())).thenReturn(1);
service.activateFile(taskId, fileId, 7L);
service.activateFile(taskId, fileId, 7L, DEVICE_A);
verify(publishFileMapper, times(1)).selectOne(any());
}
@@ -830,7 +920,7 @@ class PublishTaskServiceTest {
when(fileTaskMapper.selectById(taskId)).thenReturn(task);
when(publishFileMapper.selectById(fileId)).thenReturn(running);
service.activateFile(taskId, fileId, 7L);
service.activateFile(taskId, fileId, 7L, DEVICE_A);
verify(publishFileMapper, never()).selectOne(any());
verify(publishFileMapper, never()).update(isNull(), any());
backend-java/src/test/java/com/nanri/aiimage/modules/task/contract/ResultSuccessTimingContractTest.java
+3 -1
View File
@@ -107,7 +107,9 @@ class ResultSuccessTimingContractTest {
doAnswer(invocation -> null)
.when(publishTaskService).submitResult(eq(TASK_ID), any(PublishSubmitResultRequest.class));
ApiResponse<Void> response = new PublishController(publishTaskService)
// 第二个构造参数是 AdminAuthSupport（activateFile 取设备号用），本用例只测 submitResult，
// 不经过该依赖，故传 null（同文件其它 controller 用例亦有传 null 的先例）。
ApiResponse<Void> response = new PublishController(publishTaskService, null)
.submitResult(TASK_ID, new PublishSubmitResultRequest());
assertTrue(response.isSuccess(), "success=true");