后端(四面9分批次): 锁跳过留痕、状态词表收成单点、版本硬地板进 yml 并记账

- 14 处「拿不到锁就 continue」过去零日志,现统一带可聚合锚点并有留痕判据
  (LockSkipWitnessTest 7 例 + LockSkipSilentExitGuardrailTest 4 例)。
- 任务状态词表:散落内联集合改由单一定义点判方向(TaskStatusVocabularyRatchetTest 7 例),
  CANCELED/CANCELLED 只做归一映射,没改库值也没改对外契约。
- 版本硬地板三键(min-supported / enforce / rejectUnreported)此前在任何 yml 里 0 处=出厂即惰性;
  现在入册且 enforce=false 走记账模式(ClientVersionFloorConfigTest 9 例),真挡谁留给用户拍。
- 业务码→HTTP 状态只做映射单点 + 开关(默认关,开启前逐字节等价,BusinessErrorHttpStatusTest 8 例);
  直接翻面会让三个前端把业务失败读成网络挂了。
- 验收:mvn -o test 这 5 个类 35 例 0 红(用 python subprocess 起 mvn——bash 里 cmd 包一层
  开的是交互式 cmd,rc 是 cmd 的,会给出假的 rc=0)。
This commit is contained in:
2026-10-09 23:09:37 +08:00
parent 54cfb70a43
commit 15094309cf
63 changed files with 2454 additions and 95 deletions
@@ -0,0 +1,258 @@
package com.nanri.aiimage.common.api;
import static org.assertj.core.api.Assertions.assertThat;
import com.nanri.aiimage.testutil.SourceScan;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
/**
* 分页/条数默认值的<b>逐点台账 + 棘轮</b>(2026-10-09 评审「可读 5.0 / 交互 5.5」项 5)。
*
* <p>评审量到的是"15/20/50/1000 四种并存、31 处 {@code defaultValue}"。本轮实测更细:
* 数字型 {@code defaultValue} 共 <b>49</b> 处,其中 48 处是分页/条数口径(21 处页码 + 27 处容量与上限),
* 另有 1 处是 {@code timeout_minutes=30},不是分页。
*
* <p>这里<b>不规定"全局统一默认页容量"</b>——把 15/20/50/1000 拍成一个数是改行为。判据只做两件事:
* <ol>
* <li>每个出站点当前用什么默认值,逐点钉死({@link #LEDGER}):改任一页的默认值会红,
* 新加分页参数没登记也会红;</li>
* <li>同一个语义(page / page_size / limit)不许冒出台账之外的第二个默认值。</li>
* </ol>
*
* <p>重跑:{@code mvn -o test -Dtest=PageDefaultsLedgerTest}(cwd = backend-java)。
*/
class PageDefaultsLedgerTest {
private static final Pattern NUMERIC_DEFAULT = Pattern.compile("defaultValue\\s*=\\s*\"([0-9]+)\"");
private static final Pattern CONST_DEFAULT = Pattern.compile("defaultValue\\s*=\\s*PageDefaults\\.([A-Z_]+)");
private static final Pattern NAMED_PARAM = Pattern.compile("(?:name|value)\\s*=\\s*\"([a-z_]+)\"");
private static final Pattern TRAILING_VAR = Pattern.compile("\\b([A-Za-z_][A-Za-z0-9_]*)\\s*\\)?\\s*[,{)]?\\s*(?://.*)?$");
/**
* 出站点台账:{@code 文件#参数 -> 该页当前默认值的具名出处}。
* 48 条,逐条对应一次真实翻页行为;加页要登记,改值要表态。
*/
private static final List<String> LEDGER = List.of(
"AdminUserController.java#page=FIRST_PAGE",
"AdminUserController.java#page_size=USER_LIST_PAGE_SIZE",
"AdminUserApiSecretController.java#page=FIRST_PAGE",
"AdminUserApiSecretController.java#pageSize=USER_LIST_PAGE_SIZE",
"AdminUserSecretUsageController.java#page=FIRST_PAGE",
"AdminUserSecretUsageController.java#pageSize=USER_LIST_PAGE_SIZE",
"AdminDeviceLogController.java#page=FIRST_PAGE",
"AdminDeviceLogController.java#pageSize=ADMIN_LIST_PAGE_SIZE",
"AdminImageVideoTaskController.java#page=FIRST_PAGE",
"AdminImageVideoTaskController.java#page_size=ADMIN_LIST_PAGE_SIZE",
"AdminNotificationController.java#page=FIRST_PAGE",
"AdminNotificationController.java#pageSize=ADMIN_LIST_PAGE_SIZE",
"AppearancePatentController.java#limit=DEFAULT_RESULT_LIMIT",
"CollectDataController.java#page=FIRST_PAGE",
"CollectDataController.java#page_size=TASK_LIST_PAGE_SIZE",
"CollectDataController.java#limit=DEFAULT_RESULT_LIMIT",
"DedupeTotalDataController.java#page=FIRST_PAGE",
"DedupeTotalDataController.java#page_size=USER_LIST_PAGE_SIZE",
"ImageHistoryController.java#page=FIRST_PAGE",
"ImageHistoryController.java#page_size=USER_LIST_PAGE_SIZE",
"InvalidAsinDataController.java#page=FIRST_PAGE",
"InvalidAsinDataController.java#page_size=USER_LIST_PAGE_SIZE",
"NotificationController.java#page=FIRST_PAGE",
"NotificationController.java#pageSize=ADMIN_LIST_PAGE_SIZE",
"PriceTrackController.java#page=FIRST_PAGE",
"PriceTrackController.java#page_size=FULL_EXPORT_PAGE_SIZE",
"ProductCategoryController.java#page=FIRST_PAGE",
"ProductCategoryController.java#page=FIRST_PAGE",
"ProductCategoryController.java#page_size=ADMIN_LIST_PAGE_SIZE",
"ProductCategoryController.java#page_size=ADMIN_LIST_PAGE_SIZE",
"PublishController.java#page=FIRST_PAGE",
"PublishController.java#page_size=TASK_LIST_PAGE_SIZE",
"PublishController.java#limit=DEFAULT_RESULT_LIMIT",
"QueryAsinController.java#page=FIRST_PAGE",
"QueryAsinController.java#page_size=USER_LIST_PAGE_SIZE",
"ShopDataCrawlTaskController.java#page=FIRST_PAGE",
"ShopDataCrawlTaskController.java#limit=ADMIN_SCAN_LIMIT",
"ShopKeyController.java#page=FIRST_PAGE",
"ShopKeyController.java#pageSize=USER_LIST_PAGE_SIZE",
"ShopManageController.java#page=FIRST_PAGE",
"ShopManageController.java#pageSize=USER_LIST_PAGE_SIZE",
"ShopMatchController.java#page=FIRST_PAGE",
"ShopMatchController.java#page_size=FULL_EXPORT_PAGE_SIZE",
"SimilarAsinController.java#limit=DEFAULT_RESULT_LIMIT",
"SkipPriceAsinController.java#page=FIRST_PAGE",
"SkipPriceAsinController.java#page_size=USER_LIST_PAGE_SIZE",
"TaskFileJobController.java#limit=ADMIN_SCAN_LIMIT",
"TaskFileJobController.java#limit=ADMIN_SCAN_LIMIT");
/** 不是分页、允许继续写字面量的那 1 处(分钟数,改动它要先看 worker 超时语义)。 */
private static final List<String> NON_PAGINATION_LITERALS = List.of(
"TaskFileJobController.java#timeout_minutes=LITERAL:30");
@Test
void everyPaginationDefaultIsNamedAndLedgered() {
List<String> actual = sites();
List<String> constants = actual.stream().filter(s -> !s.contains("LITERAL")).sorted().toList();
assertThat(constants)
.as("48 处分页/条数出站点的具名默认值必须与台账一一对应")
.isEqualTo(LEDGER.stream().sorted().toList());
// 同口径非零对照:台账不是空的,扫描器也确实数得出 48 处
assertThat(constants).hasSize(48);
}
@Test
void noPaginationOutletStillCarriesABareNumber() {
List<String> literals = sites().stream().filter(s -> s.contains("LITERAL")).sorted().toList();
assertThat(literals)
.as("还剩字面量的分页点(只许 timeout_minutes 那一条非分页的在这儿)")
.isEqualTo(NON_PAGINATION_LITERALS);
}
@Test
void oneSemanticCannotGrowASecondDefault() {
List<String> actual = sites();
assertThat(kindsUsing(actual, "page", "FIRST_PAGE"))
.as("页码口径只有一套:全部从 1 起")
.isEqualTo(21);
for (String kind : List.of("page_size", "pageSize")) {
assertThat(distinctConstants(actual, kind))
.as(kind + " 的默认容量集合:15/20/50/1000 四种各自登记,新来第五种要红")
.containsExactlyInAnyOrder("USER_LIST_PAGE_SIZE", "ADMIN_LIST_PAGE_SIZE",
"TASK_LIST_PAGE_SIZE", "FULL_EXPORT_PAGE_SIZE");
}
assertThat(distinctConstants(actual, "limit"))
.as("limit 是「本次最多返回几条」,不许和 page_size 混用同一批常量")
.containsExactlyInAnyOrder("DEFAULT_RESULT_LIMIT", "ADMIN_SCAN_LIMIT");
// limit 不许出现"页容量家族"的常量,反过来也不行:语义混用会让上限与分页互相打架
assertThat(actual).noneMatch(s -> s.contains("#limit=") && s.contains("PAGE_SIZE"));
assertThat(actual).noneMatch(s -> (s.contains("#page_size=") || s.contains("#pageSize="))
&& (s.contains("RESULT_LIMIT") || s.contains("SCAN_LIMIT")));
}
@Test
void suspiciousFullExportDefaultStaysTwoSitesAndUnchanged() {
// 评审点名的疑似笔误:用户端列表默认 1000(价格追踪 + 店铺匹配两处)。
// 本轮不改数值,只把它数出来钉住——真要改成 50/100,必须在这里显式表态而不是顺手改掉。
assertThat(PageDefaults.FULL_EXPORT_PAGE_SIZE).isEqualTo("1000");
assertThat(sites().stream().filter(s -> s.endsWith("=FULL_EXPORT_PAGE_SIZE")).toList())
.containsExactlyInAnyOrder(
"PriceTrackController.java#page_size=FULL_EXPORT_PAGE_SIZE",
"ShopMatchController.java#page_size=FULL_EXPORT_PAGE_SIZE");
}
@Test
void stringAndIntMirrorsCannotDriftApart() {
// 具名常量给了 String 与 int 两个面,两者一旦漂开,注解上的默认值和代码里的兜底值就不是一个数
assertPair(PageDefaults.FIRST_PAGE, PageDefaults.FIRST_PAGE_INT);
assertPair(PageDefaults.USER_LIST_PAGE_SIZE, PageDefaults.USER_LIST_PAGE_SIZE_INT);
assertPair(PageDefaults.ADMIN_LIST_PAGE_SIZE, PageDefaults.ADMIN_LIST_PAGE_SIZE_INT);
assertPair(PageDefaults.TASK_LIST_PAGE_SIZE, PageDefaults.TASK_LIST_PAGE_SIZE_INT);
assertPair(PageDefaults.FULL_EXPORT_PAGE_SIZE, PageDefaults.FULL_EXPORT_PAGE_SIZE_INT);
assertPair(PageDefaults.DEFAULT_RESULT_LIMIT, PageDefaults.DEFAULT_RESULT_LIMIT_INT);
assertPair(PageDefaults.ADMIN_SCAN_LIMIT, PageDefaults.ADMIN_SCAN_LIMIT_INT);
}
@Test
void theFourCoexistingDefaultsAreStillFourDistinctValues() {
// 这条是"没被偷偷统一"的证明:15/20/50/1000 必须仍然互不相等。
// 如果哪天有人"顺手统一"成一个值,这条会红——那是行为变更,得单独拍板。
assertThat(PageDefaults.USER_LIST_PAGE_SIZE).isNotEqualTo(PageDefaults.ADMIN_LIST_PAGE_SIZE);
assertThat(PageDefaults.ADMIN_LIST_PAGE_SIZE).isNotEqualTo(PageDefaults.TASK_LIST_PAGE_SIZE);
assertThat(PageDefaults.TASK_LIST_PAGE_SIZE).isNotEqualTo(PageDefaults.FULL_EXPORT_PAGE_SIZE);
assertThat(List.of(PageDefaults.USER_LIST_PAGE_SIZE, PageDefaults.ADMIN_LIST_PAGE_SIZE,
PageDefaults.TASK_LIST_PAGE_SIZE, PageDefaults.FULL_EXPORT_PAGE_SIZE)).doesNotHaveDuplicates();
}
// ---------------------------------------------------------------- 助手
private static void assertPair(String literal, int mirror) {
assertThat(mirror).as("int 镜像必须等于注解上的字符串值").isEqualTo(Integer.parseInt(literal));
}
private static int kindsUsing(List<String> sites, String kind, String constant) {
String needle = "#" + kind + "=" + constant;
return (int) sites.stream().filter(s -> s.contains(needle) && !s.contains("LITERAL")).count();
}
private static List<String> distinctConstants(List<String> sites, String kind) {
String needle = "#" + kind + "=";
return sites.stream().filter(s -> s.contains(needle) && !s.contains("LITERAL"))
.map(s -> s.substring(s.indexOf('=') + 1))
.distinct().sorted().toList();
}
/** 扫出全部数字型 defaultValue 出站点,返回 {@code 文件#参数=常量} 或 {@code 文件#参数=LITERAL:值}。 */
private static List<String> sites() {
List<String> rows = new ArrayList<>();
for (Path file : mainSources()) {
String name = file.getFileName().toString();
String source = SourceScan.withoutComments(read(file));
for (String line : source.split("\n")) {
if (!line.contains("defaultValue")) {
continue;
}
String param = param(line);
Matcher c = CONST_DEFAULT.matcher(line);
if (c.find()) {
rows.add(name + "#" + param + "=" + c.group(1));
continue;
}
Matcher n = NUMERIC_DEFAULT.matcher(line);
if (n.find()) {
rows.add(name + "#" + param + "=LITERAL:" + n.group(1));
}
}
}
assertThat(rows).as("数字型/常典型 defaultValue 点位数(扫不到=路径或形状坏了)")
.hasSizeGreaterThanOrEqualTo(49);
return rows;
}
private static String param(String line) {
Matcher named = NAMED_PARAM.matcher(line);
if (named.find()) {
return named.group(1);
}
Matcher tail = TRAILING_VAR.matcher(line.strip());
return tail.find() ? tail.group(1) : "?";
}
private static List<Path> mainSources() {
Path root = moduleRoot().resolve("src/main/java");
try (Stream<Path> walk = Files.walk(root)) {
List<Path> files = walk.filter(p -> p.toString().endsWith(".java"))
.sorted(Comparator.comparing(Path::toString)).toList();
assertThat(files).as("src/main/java 扫到的 .java 数").hasSizeGreaterThan(900);
return files;
} catch (IOException e) {
throw new IllegalStateException("扫描失败: " + root, e);
}
}
private static Path moduleRoot() {
Path here = Path.of("").toAbsolutePath();
if (Files.isDirectory(here.resolve("src/main/java"))) {
return here;
}
Path nested = here.resolve("backend-java");
if (Files.isDirectory(nested.resolve("src/main/java"))) {
return nested;
}
throw new IllegalStateException("无法定位 backend-java 源码目录(cwd=" + here + ")");
}
private static String read(Path file) {
try {
return Files.readString(file);
} catch (IOException e) {
throw new IllegalStateException("读不了 " + file, e);
}
}
}
@@ -0,0 +1,269 @@
package com.nanri.aiimage.common.exception;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.service.TaskOwnerForwardService;
import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.boot.env.YamlPropertySourceLoader;
import org.springframework.core.env.EnumerablePropertySource;
import org.springframework.core.env.PropertySource;
import org.springframework.core.io.ClassPathResource;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
/**
* 业务码 → 真 HTTP 状态码的映射单点判据(2026-10-09 评审「交互 5.5」项 4,本轮只做安全的一半)。
*
* <p>要钉住的三件事,缺一半都不算做完:
* <ol>
* <li><b>默认关</b>:开关在 {@code application.yml} 里显式写着 false,且关掉时
* {@link BusinessErrorHttpStatus#render} 返回<b>同一个实例</b>——不是"看起来一样",
* 是根本没构造 {@code ResponseEntity},序列化路径与改动前逐字节相同;</li>
* <li><b>白名单是封闭的</b>:表外 code(含历史大量不带码的 {@code ApiResponse.fail(message)})
* 即使开关打开也恒走 200。这条是翻真时唯一的兜底——它保证"打开开关"的爆炸半径
* 只有白名单里那 13 个码,而不是全部 1,242 处业务失败;</li>
* <li><b>打开时只改状态行、不改响应体</b>:body 实例不变,成功响应(40901 幂等忽略)不许被拖进映射。</li>
* </ol>
*
* <p>重跑:{@code mvn -o test -Dtest=BusinessErrorHttpStatusTest}(cwd = backend-java)。
*/
@ExtendWith(MockitoExtension.class)
class BusinessErrorHttpStatusTest {
private static final Pattern PLACEHOLDER = Pattern.compile("^\\$\\{([^:}]+):([^}]*)\\}$");
@Mock private TaskOwnerForwardService taskOwnerForwardService;
@InjectMocks private GlobalExceptionHandler handler;
@AfterEach
void switchBackOff() {
BusinessErrorHttpStatus.bindForTests(false, null);
}
// ---------------------------------------------------------------- 1. 默认关
@Test
void switchShipsDeclaredAndOffInApplicationYml() {
Map<String, String> flat = flatten("application.yml");
assertThat(flat)
.as("开关必须显式写在 yml 里(「没写=隐式默认」就是版本地板踩过的坑)")
.containsKey(BusinessErrorHttpStatus.ENABLED_KEY);
assertThat(defaultOf(flat, BusinessErrorHttpStatus.ENABLED_KEY)).isEqualTo("false");
// 组件构造时把配置值搬到静态判定上;默认态必须两处一致(两套默认值会漂)
@SuppressWarnings("unchecked")
org.springframework.beans.factory.ObjectProvider<io.micrometer.core.instrument.MeterRegistry> provider =
mock(org.springframework.beans.factory.ObjectProvider.class);
when(provider.getIfAvailable()).thenReturn(null);
new BusinessErrorHttpStatus(provider, false);
assertThat(BusinessErrorHttpStatus.isEnabled())
.as("出厂态就是关:没人拍板之前不该有任何状态码变化")
.isFalse();
}
@Test
void disabledRenderReturnsTheExactSameInstance() {
BusinessErrorHttpStatus.bindForTests(false, null);
ApiResponse<Void> body = ApiResponse.fail(401, "未登录");
Object rendered = BusinessErrorHttpStatus.render(body, 401);
// 关掉时不是"造一个等价的 ResponseEntity",是根本没造——否则就不是逐字节一致
assertThat(rendered).isSameAs(body);
assertThat(rendered).isNotInstanceOf(ResponseEntity.class);
}
// ---------------------------------------------------------------- 2. 白名单封闭
@Test
void whitelistIsExactlyThePinnedCodeList() {
assertThat(BusinessErrorHttpStatus.mappings().keySet())
.as("会被映射成非 200 的 code 清单(改这里=改现网状态码契约,必须点名评审)")
.containsExactlyInAnyOrder(400, 401, 403, 404, 409, 422, 500, 503,
4011, 4012, 40401, 40902, 40903);
assertThat(BusinessErrorHttpStatus.statusFor(401)).isEqualTo(HttpStatus.UNAUTHORIZED);
assertThat(BusinessErrorHttpStatus.statusFor(403)).isEqualTo(HttpStatus.FORBIDDEN);
assertThat(BusinessErrorHttpStatus.statusFor(400)).isEqualTo(HttpStatus.BAD_REQUEST);
assertThat(BusinessErrorHttpStatus.statusFor(404)).isEqualTo(HttpStatus.NOT_FOUND);
assertThat(BusinessErrorHttpStatus.statusFor(4011))
.as("被顶下线:码族是鉴权,翻真后是 401")
.isEqualTo(HttpStatus.UNAUTHORIZED);
assertThat(BusinessErrorHttpStatus.statusFor(4012))
.as("客户端版本过低:让调用方看见 4xx 而不是 200")
.isEqualTo(HttpStatus.BAD_REQUEST);
assertThat(BusinessErrorHttpStatus.statusFor(BusinessCodes.TASK_BUSY)).isEqualTo(HttpStatus.CONFLICT);
assertThat(BusinessErrorHttpStatus.statusFor(BusinessCodes.TASK_OWNER_FORWARD))
.isEqualTo(HttpStatus.CONFLICT);
assertThat(BusinessErrorHttpStatus.statusFor(BusinessCodes.TASK_NOT_FOUND))
.isEqualTo(HttpStatus.NOT_FOUND);
}
@Test
void idempotentSuccessCodeIsNeverMappedToAnErrorStatus() {
// 40901 在 handler 里是幂等忽略、返回 success=true。它是成功响应,
// 一旦被写进映射表,翻真后"重复提交"会从 200 变 409,客户端会当成失败重试。
assertThat(BusinessErrorHttpStatus.mappings())
.as("TASK_ALREADY_FINISHED 不在白名单里")
.doesNotContainKey(BusinessCodes.TASK_ALREADY_FINISHED);
assertThat(BusinessErrorHttpStatus.statusFor(BusinessCodes.TASK_ALREADY_FINISHED))
.isEqualTo(HttpStatus.OK);
}
@Test
void codesOutsideTheWhitelistStayOnTwoHundredEvenWhenSwitchIsOn() {
BusinessErrorHttpStatus.bindForTests(true, null);
try {
// 开关开着也不能碰没预料到的码:这是翻真时唯一的爆炸半径上限
assertThat(BusinessErrorHttpStatus.statusFor(40999)).isEqualTo(HttpStatus.OK);
assertThat(BusinessErrorHttpStatus.statusFor(0)).isEqualTo(HttpStatus.OK);
assertThat(BusinessErrorHttpStatus.statusFor(200)).isEqualTo(HttpStatus.OK);
assertThat(BusinessErrorHttpStatus.statusFor(null)).isEqualTo(HttpStatus.OK);
ApiResponse<Void> body = ApiResponse.fail(40999, "没登记过的业务码");
assertThat(BusinessErrorHttpStatus.render(body, 40999)).isSameAs(body);
ApiResponse<Void> codeless = ApiResponse.fail("历史上大量不带码的失败");
assertThat(BusinessErrorHttpStatus.render(codeless, null)).isSameAs(codeless);
} finally {
BusinessErrorHttpStatus.bindForTests(false, null);
}
}
// ---------------------------------------------------------------- 3. 打开时只改状态行
@Test
void enabledRenderKeepsBodyInstanceAndOnlyChangesStatusLine() {
SimpleMeterRegistry registry = new SimpleMeterRegistry();
BusinessErrorHttpStatus.bindForTests(true, registry);
ListAppender<ILoggingEvent> captured = capture();
try {
ApiResponse<Void> body = ApiResponse.fail(403, "没有权限");
Object rendered = BusinessErrorHttpStatus.render(body, 403);
assertThat(rendered).isInstanceOfSatisfying(ResponseEntity.class, r -> {
assertThat(r.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
assertThat(r.getBody()).as("响应体必须是同一个实例,不改一个字节").isSameAs(body);
});
assertThat(captured.list.stream().map(ILoggingEvent::getFormattedMessage).toList())
.as("改写状态行这件事本身要可 grep、可聚合")
.anySatisfy(line -> assertThat(line)
.contains(BusinessErrorHttpStatus.ANCHOR)
.contains("code=403")
.contains("HTTP 403"));
assertThat(registry.get(BusinessErrorHttpStatus.METRIC)
.tag("code", "403").tag("httpStatus", "403").counter().count()).isEqualTo(1.0);
} finally {
release(captured);
registry.close();
BusinessErrorHttpStatus.bindForTests(false, null);
}
}
// ---------------------------------------------------------------- 4. 出口真的接在 handler 上
@Test
void handlerKeepsHttpTwoHundredWhileSwitchOff() {
BusinessErrorHttpStatus.bindForTests(false, null);
Object result = handler.handleBusinessException(
new BusinessException(403, "无权访问"), request(), mock(HttpServletResponse.class));
// 关掉时 handler 的返回类型都必须是 ApiResponse 本体,不是 ResponseEntity 包一层
assertThat(result).isInstanceOf(ApiResponse.class);
assertThat(result).isNotInstanceOf(ResponseEntity.class);
ApiResponse<?> body = (ApiResponse<?>) result;
assertThat(body.isSuccess()).isFalse();
assertThat(body.getCode()).isEqualTo(403);
assertThat(body.getMessage()).isNotBlank();
}
@Test
void handlerEmitsRealStatusOnceSwitchIsOn() {
SimpleMeterRegistry registry = new SimpleMeterRegistry();
BusinessErrorHttpStatus.bindForTests(true, registry);
try {
Object result = handler.handleBusinessException(
new BusinessException(403, "无权访问"), request(), mock(HttpServletResponse.class));
ResponseEntity<?> response = (ResponseEntity<?>) result;
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
ApiResponse<?> body = (ApiResponse<?>) response.getBody();
assertThat(body.getCode()).as("响应体一个字节都不许多改").isEqualTo(403);
// 第二件:幂等忽略那条成功路径即使在开关开着时也必须还是 200/ApiResponse
Object finished = handler.handleBusinessException(
new BusinessException(BusinessCodes.TASK_ALREADY_FINISHED, "任务已结束"),
request(), mock(HttpServletResponse.class));
assertThat(finished).isInstanceOf(ApiResponse.class);
assertThat(((ApiResponse<?>) finished).isSuccess()).isTrue();
} finally {
registry.close();
BusinessErrorHttpStatus.bindForTests(false, null);
}
}
// ---------------------------------------------------------------- 助手
private HttpServletRequest request() {
HttpServletRequest request = mock(HttpServletRequest.class);
when(request.getMethod()).thenReturn("POST");
when(request.getRequestURI()).thenReturn("/api/publish/tasks");
return request;
}
private ListAppender<ILoggingEvent> capture() {
Logger logger = (Logger) org.slf4j.LoggerFactory.getLogger(BusinessErrorHttpStatus.class);
ListAppender<ILoggingEvent> appender = new ListAppender<>();
appender.start();
logger.addAppender(appender);
return appender;
}
private void release(ListAppender<ILoggingEvent> appender) {
((Logger) org.slf4j.LoggerFactory.getLogger(BusinessErrorHttpStatus.class)).detachAppender(appender);
}
private Map<String, String> flatten(String fileName) {
ClassPathResource resource = new ClassPathResource(fileName);
assertThat(resource.exists()).as("classpath 上找不到 " + fileName).isTrue();
try (InputStream in = resource.getInputStream()) {
Map<String, String> flat = new LinkedHashMap<>();
for (PropertySource<?> source : new YamlPropertySourceLoader().load(fileName, resource)) {
if (source instanceof EnumerablePropertySource<?> enumerable) {
for (String name : enumerable.getPropertyNames()) {
Object value = enumerable.getProperty(name);
flat.put(name, value == null ? "" : String.valueOf(value));
}
}
}
return flat;
} catch (Exception e) {
throw new IllegalStateException("读 " + fileName + " 失败", e);
}
}
private String defaultOf(Map<String, String> flat, String key) {
String raw = flat.get(key).trim();
Matcher m = PLACEHOLDER.matcher(raw);
return m.matches() ? m.group(2).trim() : raw;
}
}
@@ -0,0 +1,326 @@
package com.nanri.aiimage.common.task;
import static org.assertj.core.api.Assertions.assertThat;
import com.nanri.aiimage.testutil.SourceScan;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
/**
* 状态词表收口判据(2026-10-09 评审「流程 6.0」项 2:状态字面量集合散落 33 处/17 文件、没有单一状态机)。
*
* <p>普查结果先说清楚,因为"收成一套"这句话本身是错的:全树实际是
* <b>4 套自有词表 + 1 套外部词表 + 一堆模块内小状态机</b>——
* {@code biz_file_task.status}(大写)、{@code brand_crawl_tasks.status}(<b>小写</b>)、
* {@code task_file_job.status}(四态)、{@code price_track_loop_run.status}(多一个 {@code STOPPED}),
* 外加 Coze 工作流回传的 {@code execute_status}({@code SUCCESS/SUCCEEDED/COMPLETED/DONE/FINISHED/FAILED/FAIL/…},
* 那是别人家的返回值)。所以做的是<b>按表分组、一处定义</b>,不是把四套强行洗成一套。
*
* <p>四条判据,各管一件事:
* <ol>
* <li>词表成员钉死:改 {@link TaskStatuses} 里任何一个集合必须在这里同步表态;</li>
* <li>新增"内联状态集合字面量"即红:现存 3 处逐条台账化({@link #LEDGER});</li>
* <li>散落的 {@code STATUS_XXX = "字面量"} 标量声明数抬成棘轮(只许降),已收口的 brand 小写族点名归零;</li>
* <li>{@code CANCELED}/{@code CANCELLED} 只做归一映射、不改拼写:映射判、不误伤判、写侧零命中判(配非零对照)。</li>
* </ol>
*
* <p>重跑:{@code mvn -o test -Dtest=TaskStatusVocabularyRatchetTest}(cwd = backend-java)。
*/
class TaskStatusVocabularyRatchetTest {
/**
* 判定"这是一个状态字面量"的词表——取自 {@link TaskStatuses} 本身,免得判据和被管对象各写一套。
* 大写四套 + brand 小写一套都要覆盖:只扫大写的话,新抄一处 {@code Set.of("pending","running")}
* 就从判据底下滑过去了。
*/
private static final Set<String> VOCABULARY = java.util.stream.Stream
.concat(TaskStatuses.allUppercaseStatuses().stream(),
java.util.stream.Stream.of(TaskStatuses.BrandTask.PENDING, TaskStatuses.BrandTask.RUNNING,
TaskStatuses.BrandTask.SUCCESS, TaskStatuses.BrandTask.FAILED,
TaskStatuses.BrandTask.CANCELLED))
.collect(java.util.stream.Collectors.toUnmodifiableSet());
private static final Pattern OPEN = Pattern.compile("\\b(?:Set|List|Collection|EnumSet)\\.of\\(|\\bArrays\\.asList\\(");
private static final Pattern QUOTED = Pattern.compile("\"([A-Za-z_]+)\"");
/**
* 内联状态集合字面量的例外台账:文件 → 为什么留在这儿。
* 加一行要写清理由;删一行就是真的收掉了一处。
*/
private static final Map<String, String> LEDGER = Map.of(
"ImageVideoAsyncTaskService.java",
"Coze 上游回传的 execute_status 词表(SUCCEEDED/DONE/FINISHED/FAIL 都是别人家的值),"
+ "收进我们的词表等于假装能改上游",
"CompletedTaskActiveJobInspector.java",
"同一对状态的反序书写 List.of(\"RUNNING\",\"PENDING\");对 SQL 无意义,"
+ "但本仓有判据按 SQL 文本顺序断言(TaskCenterQueryMapperSqlTest),改序之前先承认它在台账里");
/** 标量 {@code STATUS_X = "字面量"} 声明的棘轮分母(本轮从 81 降到 70:brand 小写族 11 处已接进词表)。 */
private static final int SCALAR_LITERAL_CEILING = 70;
// ---------------------------------------------------------------- 1. 词表成员
@Test
void centralVocabularyMembersArePinned() {
assertThat(TaskStatuses.FileTask.TERMINAL)
.as("biz_file_task 终态:少一个历史拼写就有一行永远收不了尾")
.containsExactlyInAnyOrder("SUCCESS", "FAILED", "CANCELLED", "CANCELED");
assertThat(TaskStatuses.FileTask.ACTIVE)
.containsExactlyInAnyOrder("PENDING", "RUNNING", "SCHEDULED");
assertThat(TaskStatuses.FileTask.FINISHED_ORDERED)
.as("各模块历史页计数口径:只有 SUCCESS+FAILED,不含取消(原口径,别顺手加宽)")
.containsExactly("SUCCESS", "FAILED");
assertThat(TaskStatuses.FileTask.SUCCESS_VIEW_ORDERED)
.as("COMPLETED ≡ SUCCESS 早有出处(2026-10-04 三态收敛),这里只是把它钉成一处")
.containsExactly("SUCCESS", "COMPLETED");
assertThat(TaskStatuses.FileTask.FAILED_VIEW_ORDERED)
.containsExactly("FAILED", "ERROR", "CANCELLED");
assertThat(TaskStatuses.BrandTask.TERMINAL)
.as("brand 表是小写词表,混进大写集合会让 UNION 少一整张表")
.containsExactlyInAnyOrder("success", "failed", "cancelled");
assertThat(TaskStatuses.Job.RETRYABLE_ORDERED).containsExactly("PENDING", "FAILED");
assertThat(TaskStatuses.Job.ACTIVE_ORDERED).containsExactly("PENDING", "RUNNING");
assertThat(TaskStatuses.LoopRun.TERMINAL)
.containsExactlyInAnyOrder("SUCCESS", "FAILED", "STOPPED");
// 否定句也要有同口径非零对照:确认"终态里没有 DONE/FINISHED/INTERRUPTED 这类新造词"不是因为集合整个是空的
assertThat(TaskStatuses.FileTask.TERMINAL).isNotEmpty();
assertThat(TaskStatuses.FileTask.TERMINAL)
.as("不能发明第三个词表:DONE/FINISHED/SUCCEEDED 不属于我们")
.doesNotContain("DONE", "FINISHED", "SUCCEEDED", "INTERRUPTED", "ARCHIVED");
}
// ---------------------------------------------------------------- 2. 内联状态集合棘轮
@Test
void inlineStatusCollectionLiteralsStayLedgeredAndCannotGrow() {
Map<String, Integer> found = inlineStatusCollections();
assertThat(found)
.as("内联状态集合字面量必须逐文件台账化;新出现一个文件就是新抄了一套状态口径")
.containsOnlyKeys(LEDGER.keySet().toArray(new String[0]));
// 总数硬钉:现在就是 3 处(2 处外部词表 + 1 处反序书写),不是"扫不到所以绿"
assertThat(found.values().stream().mapToInt(Integer::intValue).sum())
.as("内联状态集合字面量总数(基线 3:ImageVideo 外部词表 2 处 + Inspector 反序 1 处)")
.isEqualTo(3);
assertThat(found).hasEntrySatisfying("ImageVideoAsyncTaskService.java", count ->
assertThat(count).as("Coze 外部词表两处都在").isEqualTo(2));
assertThat(found).hasEntrySatisfying("CompletedTaskActiveJobInspector.java", count ->
assertThat(count).isEqualTo(1));
}
@Test
void theCollectionScannerActuallyFindsTheShape() {
// 自检:上一条判据全靠这个扫描器。扫描器坏了(恒返回空)就是整支护栏恒绿,所以先证明它抓得到这一形。
String sample = SourceScan.withoutComments(
"class X { Set<String> A = Set.of(\"SUCCESS\", \"FAILED\", \"CANCELLED\"); }");
assertThat(countStatusLiterals(sample))
.as("锚点自检:抓不到 Set.of(\"SUCCESS\",\"FAILED\",…) 的话,棘轮等于没写")
.isEqualTo(3);
assertThat(countStatusLiterals("class X { List<String> A = List.of(\"PENDING\")); }")).isEqualTo(1);
assertThat(countStatusLiterals("class X { List<String> A = List.of(\"DE\", \"UK\", \"FR\")); }"))
.as("国家码不是状态词,别把无关的 List.of 也算进分母")
.isZero();
}
// ---------------------------------------------------------------- 3. 标量声明棘轮
@Test
void handWrittenStatusScalarsRatchetDownAndBrandFamilyIsClosed() {
Map<String, Integer> scalars = statusScalarDeclarations();
int total = scalars.values().stream().mapToInt(Integer::intValue).sum();
assertThat(total)
.as("src/main 里写死字面量的 STATUS_XXX 标量声明数(棘轮:只许降。降法是接进 TaskStatuses)")
.isLessThanOrEqualTo(SCALAR_LITERAL_CEILING);
assertThat(total).as("扫描器必须真数得出东西;0 处不等于收口完成,等于扫描坏了").isGreaterThan(0);
// 点名已收口的那一族:brand 小写词表 11 处标量全部改成引用词表,一处不许回来
for (String closed : List.of("BrandTaskService.java", "BrandTaskExpiredStopSpiImpl.java",
"BrandTaskStaleRepairSpiImpl.java")) {
assertThat(scalars.getOrDefault(closed, 0))
.as(closed + " 的状态常量必须引用 TaskStatuses.BrandTask,不许再写死字面量")
.isZero();
}
}
@Test
void brandTaskServiceAndHeartbeatStillSpeakTheLowercaseVocabulary() {
// 接进词表之后值不许变:brand_crawl_tasks 存的就是小写,改成大写等于把在跑任务判成不存在
assertThat(TaskStatuses.BrandTask.PENDING).isEqualTo("pending");
assertThat(TaskStatuses.BrandTask.RUNNING).isEqualTo("running");
assertThat(TaskStatuses.BrandTask.CANCELLED).isEqualTo("cancelled");
// 文件任务那张表仍是同一批大写值,两套不许互相"归一"
assertThat(TaskStatuses.FileTask.RUNNING).isEqualTo("RUNNING");
assertThat(TaskStatuses.FileTask.RUNNING).isNotEqualTo(TaskStatuses.BrandTask.RUNNING);
}
// ---------------------------------------------------------------- 4. CANCELED / CANCELLED
@Test
void cancelSpellingIsOnlyNormalizedNeverRenamed() {
assertThat(TaskStatuses.CANCEL_SPELLINGS)
.as("两种拼写 × 两种大小写各归各家")
.containsEntry("CANCELED", "CANCELLED")
.containsEntry("canceled", "cancelled");
// 第二件:只动取消族,别的状态一个字节都不许多改(防止"归一"顺手把 COMPLETED 洗成 SUCCESS)
assertThat(TaskStatuses.canonicalizeCancel("CANCELED")).isEqualTo("CANCELLED");
assertThat(TaskStatuses.canonicalizeCancel("RUNNING")).isEqualTo("RUNNING");
assertThat(TaskStatuses.canonicalizeCancel("COMPLETED")).isEqualTo("COMPLETED");
assertThat(TaskStatuses.canonicalizeCancel("success")).isEqualTo("success");
assertThat(TaskStatuses.canonicalizeCancel(null)).isNull();
assertThat(TaskStatuses.isCancelSpelling("CANCELED")).isTrue();
assertThat(TaskStatuses.isCancelSpelling("CANCELLED")).isTrue();
assertThat(TaskStatuses.isCancelSpelling("FAILED")).as("FAILED 不是取消的拼写变体").isFalse();
}
@Test
void backendNeverWritesTheLegacyCanceledSpellingIntoAnyTable() {
// 实测边界:当前 Java 侧从不写 CANCELED(大写单 L)进库——它只可能是早期 jar/Python 留下的历史脏值,
// 所以只在读侧接受集合与 SQL 的 CASE WHEN 归一里出现。
Map<String, Integer> writes = statusWrites("\"CANCELED\"");
int hits = writes.values().stream().mapToInt(Integer::intValue).sum();
assertThat(hits).as("把 \"CANCELED\" 写进库的语句数(历史脏值不许被新代码继续生产)").isZero();
// 同口径非零对照:同一支扫描器必须抓得到"小写 cancelled"的真实写点,否则上面那句 0 是扫描坏了
Map<String, Integer> control = statusWrites("\"cancelled\"");
assertThat(control.values().stream().mapToInt(Integer::intValue).sum())
.as("小写 cancelled 的写点数(brand 表确实在写这个值)")
.isGreaterThan(0);
}
// ---------------------------------------------------------------- 扫描助手
/** 文件 → 含 ≥2 个状态词的内联集合字面量处数。 */
private static Map<String, Integer> inlineStatusCollections() {
Map<String, Integer> byFile = new TreeMap<>();
for (Path file : mainSources()) {
if ("TaskStatuses.java".equals(file.getFileName().toString())) {
continue; // 这里就是唯一定义点,不该进例外台账
}
String source = SourceScan.withoutComments(read(file));
Matcher m = OPEN.matcher(source);
while (m.find()) {
String args = arguments(source, m.end() - 1);
if (args != null && countStatusLiterals(args) >= 2) {
byFile.merge(file.getFileName().toString(), 1, Integer::sum);
}
}
}
return byFile;
}
private static int countStatusLiterals(String text) {
Matcher m = QUOTED.matcher(text);
int n = 0;
while (m.find()) {
if (VOCABULARY.contains(m.group(1))) {
n++;
}
}
return n;
}
/** 文件 → 匹配 {@code writeFragment} 的处数(用于"某状态值有没有被写进库"的取证)。 */
private static Map<String, Integer> statusWrites(String writeFragment) {
Map<String, Integer> byFile = new TreeMap<>();
Pattern p = Pattern.compile("set\\([^)]*Status[^)]*,\\s*" + Pattern.quote(writeFragment));
for (Path file : mainSources()) {
Matcher m = p.matcher(SourceScan.withoutComments(read(file)));
int n = 0;
while (m.find()) {
n++;
}
if (n > 0) {
byFile.put(file.getFileName().toString(), n);
}
}
return byFile;
}
private static Map<String, Integer> statusScalarDeclarations() {
Map<String, Integer> byFile = new TreeMap<>();
Pattern p = Pattern.compile(
"static final String (?:STATUS|STATE)_[A-Z_]+\\s*=\\s*\"[A-Za-z_]+\"");
for (Path file : mainSources()) {
if ("TaskStatuses.java".equals(file.getFileName().toString())) {
continue;
}
Matcher m = p.matcher(SourceScan.withoutComments(read(file)));
int n = 0;
while (m.find()) {
n++;
}
if (n > 0) {
byFile.put(file.getFileName().toString(), n);
}
}
return byFile;
}
/** 从左括号开始做深度配对,取括号内文本;配不平返回 null(宁可漏判一处也不要把判据搞成假红)。 */
private static String arguments(String text, int openIndex) {
int depth = 0;
for (int i = openIndex; i < text.length(); i++) {
char c = text.charAt(i);
if (c == '(') {
depth++;
} else if (c == ')') {
depth--;
if (depth == 0) {
return text.substring(openIndex + 1, i);
}
if (depth < 0) {
return null;
}
}
}
return null;
}
private static List<Path> mainSources() {
Path root = moduleRoot().resolve("src/main/java");
try (Stream<Path> walk = Files.walk(root)) {
List<Path> files = walk.filter(p -> p.toString().endsWith(".java"))
.sorted(Comparator.comparing(Path::toString))
.toList();
assertThat(files).as("src/main/java 扫到的 .java 数(扫不到=路径坏了,护栏会假绿)")
.hasSizeGreaterThan(900);
return files;
} catch (IOException e) {
throw new IllegalStateException("扫描失败: " + root, e);
}
}
private static Path moduleRoot() {
Path here = Path.of("").toAbsolutePath();
if (Files.isDirectory(here.resolve("src/main/java"))) {
return here;
}
Path nested = here.resolve("backend-java");
if (Files.isDirectory(nested.resolve("src/main/java"))) {
return nested;
}
throw new IllegalStateException("无法定位 backend-java 源码目录(cwd=" + here + ")");
}
private static String read(Path file) {
try {
return Files.readString(file);
} catch (IOException e) {
throw new IllegalStateException("读不了 " + file, e);
}
}
}
@@ -0,0 +1,233 @@
package com.nanri.aiimage.common.util;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import com.nanri.aiimage.testutil.SourceScan;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
/**
* 锁跳过出口的<b>逐处</b>判据(2026-10-09 评审「稳定 5.5」项 1,权重 1.5)。
*
* <p>要拦的行为很具体:{@code if (<某个 lock 变量> == null) { continue; }} /
* {@code { return; }} —— 巡检任务每轮跑、被锁挡掉的任务直接消失,一行日志都不留。
* 实测基线(2026-10-10 自己数出来的,不是评审给的 14):全树 {@code src/main/java} 共
* <b>29</b> 处这种形状,28 处已接 {@link LockSkipWitness},1 处判定不该接(见
* {@link #LEDGERED_EXCEPTIONS})。
*
* <p>判据打在<b>分支体</b>上而不是打在"某个类里出现过锚点"上:分支体剥掉注释后必须只剩
* {@code continue;} / {@code return;}(顶多一行 {@code LockSkipWitness.*} 调用)。
* 这样"锚点方法存在但没人调"(2026-10-09 踩过的那坑)在这儿会直接红——
* {@link #witnessedSiteCountCannotShrink} 把已接线的点位数钉成 28,掉一处就红,
* {@link #everyPointLiteralIsUsedByExactlyOneSite} 保证点位没有互相覆盖成一坨。
*/
class LockSkipSilentExitGuardrailTest {
/** 形如 lock / jobLock / taskLockHandle / neverReportedLock / distributedJobLockService 的变量判空。 */
private static final Pattern LOCK_NULL_CHECK =
Pattern.compile("if\\s*\\(\\s*(\\w*[Ll]ock\\w*)\\s*==\\s*null\\s*\\)\\s*\\{");
/** 分支体剥掉出口调用后,只剩这两种语句就是「跳过但什么都不做」。 */
private static final List<String> BARE_EXITS = List.of("continue;", "return;");
private static final Pattern WITNESS_CALL = Pattern.compile("LockSkipWitness\\.\\w+\\s*\\(([^;]*)\\);");
/**
* 例外台账:<b>文件名 -&gt; 判定不该接的原因</b>。加一行要有现网证据,删一行就是补了出口。
*
* <p>{@code TaskDistributedLockService.close()} 里的 {@code heldLock == null} 不是"跳过任务":
* 它是重复 close 的幂等护栏(第二次 close 时本地登记已经没了,无事可做),不挡任何工作、
* 也不丢数据。给它加锚点等于每次正常重复 close 都刷一条 WARN,把真正在响的那 28 处淹掉。
*/
private static final Set<String> LEDGERED_EXCEPTIONS =
Set.of("TaskDistributedLockService.java");
/** 已接线点位数的硬分母:只许升(新增出口),不许降(出口被摘)。 */
private static final int MIN_WITNESSED_SITES = 28;
@Test
void everyLockNullSkipBranchCarriesAVisibleWitness() {
List<String> unwitnessed = new ArrayList<>();
int witnessed = 0;
for (Path file : mainSources()) {
String source = SourceScan.withoutComments(read(file));
for (String body : lockNullBranches(source)) {
if (!isSkipOnlyBranch(body)) {
continue;
}
if (body.contains("LockSkipWitness.")) {
witnessed++;
} else if (!LEDGERED_EXCEPTIONS.contains(file.getFileName().toString())) {
unwitnessed.add(file.getFileName() + " -> " + body.strip());
}
}
}
// 自检(否定句必须配同口径非零对照):扫描器真抓得到已接线的那批,否则下面那句 isEmpty() 是恒绿
assertThat(witnessed)
.as("已接 LockSkipWitness 的锁跳过点位数(掉一处就是在摘出口)")
.isGreaterThanOrEqualTo(MIN_WITNESSED_SITES);
assertThat(unwitnessed)
.as("剩下「判空即跳过且零日志」的锁出口,必须全在例外台账里")
.isEmpty();
}
@Test
void lockedExceptionsStayExactlyOneAndCannotGrowQuietly() {
List<String> bareExceptions = new ArrayList<>();
for (Path file : mainSources()) {
if (!LEDGERED_EXCEPTIONS.contains(file.getFileName().toString())) {
continue;
}
String source = SourceScan.withoutComments(read(file));
for (String body : lockNullBranches(source)) {
if (isSkipOnlyBranch(body) && !body.contains("LockSkipWitness.")) {
bareExceptions.add(file.getFileName() + ":" + body.strip());
}
}
}
// 台账里那个例外只剩 1 处(close() 的幂等护栏)。变成 2 处说明同一个文件里又新写了一处裸跳过,
// 那不是"台账里已论证过的形状",必须停下来看。
assertThat(bareExceptions)
.as("例外台账文件里的裸跳过分支数(基线:TaskDistributedLockService.close() 一处)")
.hasSize(1);
}
/**
* 「跳过但什么都不做」的分支体:剥掉出口调用与空白后,只剩 {@code continue;} 或 {@code return;}。
* 有别的语句(比如 {@code taskFileJobService.requeue(...)})就不是被拦的对象——那条路本来就留了痕。
*/
private static boolean isSkipOnlyBranch(String body) {
String stripped = body.replaceAll("LockSkipWitness\\.\\w+\\s*\\([^;]*\\);", "").strip();
return BARE_EXITS.contains(stripped);
}
@Test
void everyPointLiteralIsUsedByExactlyOneSite() {
List<String> points = new ArrayList<>();
for (Path file : mainSources()) {
if ("LockSkipWitness.java".equals(file.getFileName().toString())) {
continue;
}
Matcher m = WITNESS_CALL.matcher(SourceScan.withoutComments(read(file)));
while (m.find()) {
String args = m.group(1);
String first = args.split(",")[0].strip();
if (first.startsWith("\"") && first.endsWith("\"") && first.length() > 2) {
points.add(first);
} else if (!first.isBlank()) {
fail("点位字面量必须写死在第一个参数(不打行号、不拼变量),实际=" + args
+ " @ " + file.getFileName());
}
}
}
Set<String> distinct = new LinkedHashSet<>(points);
assertThat(points)
.as("全树 LockSkipWitness 调用数")
.hasSizeGreaterThanOrEqualTo(MIN_WITNESSED_SITES);
assertThat(distinct)
.as("点位字面量必须一一对应:两个跳过处共用一个点位,现网就分不出是谁在被挡")
.hasSize(points.size());
// 命名口径也钉一下:点位都是小写 kebab,允许带一个 ":用途" 后缀。
// 带后缀的是任务级点位(模块内多处跳过要分得开);不带后缀的是作业锁点位,
// 它直接沿用 tryLock 已有的锁名(如 expired-account-task-stop),不去另起一套标识。
assertThat(distinct).allSatisfy(point ->
assertThat(point).matches("\"[a-z0-9][a-z0-9.-]*(:[a-z0-9.-]+)?\""));
}
@Test
void anchorIsReusedFromTheSingleDefinitionPoint() {
// 锚点只有 LockSkipWitness 一处定义;业务侧禁止把 "[lock-skip]" 抄成字面量,
// 否则改了常量之后 grep 得到的是半套出口。
String witnessSource = SourceScan.withoutComments(SourceScan.sourceText("LockSkipWitness.java"));
assertThat(witnessSource).contains("public static final String ANCHOR = \"[lock-skip]\"");
List<String> copycats = new ArrayList<>();
for (Path file : mainSources()) {
if ("LockSkipWitness.java".equals(file.getFileName().toString())) {
continue;
}
if (SourceScan.withoutComments(read(file)).contains("[lock-skip]")) {
copycats.add(file.getFileName().toString());
}
}
assertThat(copycats).as("[lock-skip] 字面量不得在业务侧被抄第二遍").isEmpty();
}
// ---- 扫描助手:抓 if (<lock> == null) { … } 的分支体(含大括号配对,注释已剥) ----
private static List<String> lockNullBranches(String sourceWithoutComments) {
List<String> bodies = new ArrayList<>();
Matcher m = LOCK_NULL_CHECK.matcher(sourceWithoutComments);
while (m.find()) {
int open = m.end() - 1;
int close = matchingBrace(sourceWithoutComments, open);
if (close > open) {
bodies.add(sourceWithoutComments.substring(open + 1, close));
}
}
return bodies;
}
/** 朴素大括号配对(剥注释后字符串字面量里的大括号仍可能干扰,够用即止:只在判空分支上用)。 */
private static int matchingBrace(String text, int openIndex) {
int depth = 0;
for (int i = openIndex; i < text.length(); i++) {
char c = text.charAt(i);
if (c == '{') {
depth++;
} else if (c == '}') {
depth--;
if (depth == 0) {
return i;
}
}
}
return -1;
}
private static List<Path> mainSources() {
Path root = moduleRoot().resolve("src/main/java");
try (Stream<Path> walk = Files.walk(root)) {
List<Path> files = walk.filter(p -> p.toString().endsWith(".java"))
.sorted(Comparator.comparing(Path::toString))
.toList();
assertThat(files).as("src/main/java 扫到的 .java 数(扫不到就是路径坏了)")
.hasSizeGreaterThan(900);
return files;
} catch (IOException e) {
throw new IllegalStateException("扫描失败: " + root, e);
}
}
private static Path moduleRoot() {
Path here = Path.of("").toAbsolutePath();
if (Files.isDirectory(here.resolve("src/main/java"))) {
return here;
}
Path nested = here.resolve("backend-java");
if (Files.isDirectory(nested.resolve("src/main/java"))) {
return nested;
}
throw new IllegalStateException("无法定位 backend-java 源码目录(cwd=" + here + ")");
}
private static String read(Path file) {
try {
return Files.readString(file);
} catch (IOException e) {
throw new IllegalStateException("读不了 " + file, e);
}
}
}
@@ -0,0 +1,182 @@
package com.nanri.aiimage.common.util;
import static org.assertj.core.api.Assertions.assertThat;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import io.micrometer.core.instrument.Measurement;
import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory;
/**
* 分布式锁跳过出口({@link LockSkipWitness})的判据(2026-10-09 评审「稳定 5.5」项 1)。
*
* <p>这条判据要钉住的是<b>两件事</b>,不是两件里的一件:
* <ol>
* <li>锚点字面量真的打在日志上(能被巡检 grep);</li>
* <li>调用它确实<b>累计</b>得出数(可聚合,不是"记了一行没人看的日志")。</li>
* </ol>
* 只判第 1 件就会重演 2026-10-09 踩过的坑:锚点方法存在、零调用者,判据恒绿而现网照旧。
* 调用面由 {@link LockSkipSilentExitGuardrailTest} 按点位台账逐处钉住,两支合起来才是"出口在响"。
*/
class LockSkipWitnessTest {
@AfterEach
void unbindRegistry() {
LockSkipWitness.bind(null);
}
private ListAppender<ILoggingEvent> capture() {
Logger logger = (Logger) LoggerFactory.getLogger(LockSkipWitness.class);
ListAppender<ILoggingEvent> appender = new ListAppender<>();
appender.start();
logger.addAppender(appender);
return appender;
}
private void release(ListAppender<ILoggingEvent> appender) {
((Logger) LoggerFactory.getLogger(LockSkipWitness.class)).detachAppender(appender);
}
@Test
void recordEmitsAnchorLineWithAggregationFields() {
ListAppender<ILoggingEvent> captured = capture();
try {
long before = LockSkipWitness.total();
LockSkipWitness.record("test:anchor-shape", LockSkipWitness.OUTCOME_SKIPPED, "PUBLISH", 123L);
List<String> messages = captured.list.stream().map(ILoggingEvent::getFormattedMessage).toList();
assertThat(messages).as("走到跳过分支必须留下一行日志").hasSize(1);
String line = messages.get(0);
// 锚点 + 聚合维度都得在这一行里,巡检才分得出是哪个点位、挡了多少
assertThat(line).contains(LockSkipWitness.ANCHOR)
.contains("point=test:anchor-shape")
.contains("outcome=skipped")
.contains("moduleType=PUBLISH")
.contains("taskId=123");
assertThat(captured.list.get(0).getLevel().toString()).isEqualTo("WARN");
assertThat(LockSkipWitness.total()).as("同一行也必须进台账计数").isEqualTo(before + 1);
} finally {
release(captured);
}
}
@Test
void ledgerAggregatesPerPointAndSnapshotIsReadable() {
LockSkipWitness.resetLedgerForTests();
LockSkipWitness.recordSkip("test:agg-a", "BRAND", 1L);
LockSkipWitness.recordSkip("test:agg-a", "BRAND", 2L);
LockSkipWitness.abandoned("test:agg-b");
assertThat(LockSkipWitness.countOf("test:agg-a")).isEqualTo(2);
assertThat(LockSkipWitness.countOf("test:agg-b")).isEqualTo(1);
assertThat(LockSkipWitness.countOf("test:never-recorded")).as("没记过的点位读数必须是 0 而不是抛").isZero();
assertThat(LockSkipWitness.snapshot())
.as("快照要能一次看全点位(巡检/告警的取数面)")
.containsEntry("test:agg-a", 2L)
.containsEntry("test:agg-b", 1L);
assertThat(LockSkipWitness.total()).isEqualTo(3);
}
@Test
void skippedAndAbandonedAreTwoDifferentOutcomes() {
LockSkipWitness.resetLedgerForTests();
ListAppender<ILoggingEvent> captured = capture();
try {
LockSkipWitness.recordSkip("test:outcome-skipped", "PUBLISH", 7L);
LockSkipWitness.recordAbandoned("test:outcome-abandoned", "PUBLISH", 8L);
List<String> lines = captured.list.stream().map(ILoggingEvent::getFormattedMessage).toList();
assertThat(lines).hasSize(2);
assertThat(lines.get(0)).contains("outcome=skipped");
assertThat(lines.get(1)).contains("outcome=abandoned");
// 两种结果都得进台账——只有一种被数到就等于另一种仍然没有出口
assertThat(LockSkipWitness.snapshot()).containsKeys("test:outcome-skipped", "test:outcome-abandoned");
} finally {
release(captured);
}
}
@Test
void micrometerCounterCarriesPointAndOutcomeTagsWhenBound() {
LockSkipWitness.resetLedgerForTests();
SimpleMeterRegistry registry = new SimpleMeterRegistry();
LockSkipWitness.bind(registry);
try {
LockSkipWitness.record("test:metric-shape", LockSkipWitness.OUTCOME_ABANDONED, "SIMILAR_ASIN", 9L);
List<String> found = new ArrayList<>();
for (var meter : registry.getMeters()) {
if (LockSkipWitness.METRIC.equals(meter.getId().getName())) {
found.add(meter.getId().getTag("point") + "/" + meter.getId().getTag("outcome")
+ "/" + meter.getId().getTag("moduleType"));
}
}
assertThat(found).as("指标必须带得上点位/结果/模块三个聚合标签").containsExactly(
"test:metric-shape/abandoned/SIMILAR_ASIN");
double value = registry.get(LockSkipWitness.METRIC)
.tag("point", "test:metric-shape")
.counter()
.count();
assertThat(value).isEqualTo(1.0);
assertThat(registry.get(LockSkipWitness.METRIC + ".total").gauge().value())
.as("总览 gauge 也在,读数为零时能区分「没人被挡」和「指标没接上」")
.isGreaterThanOrEqualTo(1.0);
} finally {
registry.close();
}
}
@Test
void missingContextLandsOnKnownBucketInsteadOfThrowing() {
LockSkipWitness.resetLedgerForTests();
ListAppender<ILoggingEvent> captured = capture();
try {
// 点位缺失 + 模块缺失:不能抛,也不能悄悄丢掉这次记录
LockSkipWitness.record(null, null, " ", null);
assertThat(captured.list).hasSize(1);
assertThat(captured.list.get(0).getFormattedMessage())
.contains("point=unpointed")
.as("缺失的 outcome 单独进 unknown 桶,不许折叠进 skipped/abandoned 那两个真桶")
.contains("outcome=unknown")
.contains("moduleType=unknown");
assertThat(LockSkipWitness.countOf("unpointed")).isEqualTo(1);
assertThat(LockSkipWitness.snapshot()).containsKey("unpointed");
} finally {
release(captured);
}
}
@Test
void ledgerStopsGrowingPastItsKeyCeilingButKeepsCounting() {
LockSkipWitness.resetLedgerForTests();
for (int i = 0; i < LockSkipWitness.LEDGER_KEYS_MAX + 60; i++) {
LockSkipWitness.record("test:flood-" + i, LockSkipWitness.OUTCOME_SKIPPED, null, null);
}
assertThat(LockSkipWitness.snapshot())
.as("点位键数封顶,不被未知点位撑爆内存")
.hasSizeLessThanOrEqualTo(LockSkipWitness.LEDGER_KEYS_MAX + 1);
assertThat(LockSkipWitness.snapshot()).containsKey("overflow");
assertThat(LockSkipWitness.total())
.as("封顶只影响键的数量,不影响总次数:一次都不能少记")
.isEqualTo(LockSkipWitness.LEDGER_KEYS_MAX + 60L);
}
@Test
void anchorLiteralIsTheContractInspectionGreps() {
// 巡检/告警按这条字面量匹配;改它等于删掉现网规则,所以这里钉死字面值
assertThat(LockSkipWitness.ANCHOR).isEqualTo("[lock-skip]");
assertThat(LockSkipWitness.METRIC).isEqualTo("aiimage.distributed.lock.skip");
// 另一半:锚点必须真被 record() 打进日志(不是只当常量挂着)——上一条用例已实测,
// 这里再钉一次源码形状,防止有人把 log.warn 里的 ANCHOR 换成写死的别的字符串。
String source = com.nanri.aiimage.testutil.SourceScan.withoutComments(
com.nanri.aiimage.testutil.SourceScan.sourceText("LockSkipWitness.java"));
assertThat(source).as("record() 里的日志必须带锚点参数").contains("ANCHOR, key");
}
}
@@ -0,0 +1,315 @@
package com.nanri.aiimage.config;
import static org.assertj.core.api.Assertions.assertThat;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory;
import org.springframework.boot.env.YamlPropertySourceLoader;
import org.springframework.core.env.EnumerablePropertySource;
import org.springframework.core.env.PropertySource;
import org.springframework.core.io.ClassPathResource;
import org.springframework.mock.web.MockFilterChain;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.util.ReflectionTestUtils;
/**
* 版本硬地板三键的<b>配置面</b>判据(2026-10-09 评审「流程 6.0」项 3,服务端这一半)。
*
* <p>评审量到的事实是:{@code min-supported} / {@code enforce} / {@code rejectUnreported}
* 三键<b>在任何 yml 里 0 处</b>,只有 {@link ClientVersionGuardFilter} 里的 {@code @Value} 默认值。
* 后果不是"值不对",是<b>出厂即惰性</b>:{@code minSupportedVersion} 默认空串 ⇒
* {@code shouldNotFilter} 每个请求直接跳过 ⇒ 连"记账"都不发生,谁也不知道翻 true 会打到谁。
*
* <p>这一支钉四件事,每件都是能跑的断言不是文字:
* <ol>
* <li>三键在 {@code application.yml} 里真存在(打进 jar 的那份,读 classpath 不读工作区);</li>
* <li>出厂默认值就是 {@code 4.0.47 / false / false},且 {@code enforce=false} 那一档
* <b>确实在记账</b>——旧版本被计数、被留日志,同时响应一个字节都不许多;</li>
* <li>三键缺失(地板被改回空)时<b>启动可见</b>:一条点名"闸门惰性"的 WARN,而不是静默跳过;</li>
* <li>其它 profile 没把地板偷偷改回空值。</li>
* </ol>
*
* <p>翻真({@code enforce=true})这一轮<b>没有发生</b>,也不该由我拍:判据 2 量出来的
* {@code verdict=below}/{@code unreported} 两个桶就是"翻上去会挡到谁"的现网答案。
*
* <p>重跑:{@code mvn -o test -Dtest=ClientVersionFloorConfigTest}(cwd = backend-java)。
*/
class ClientVersionFloorConfigTest {
private static final String KEY_MIN = "aiimage.client-version.min-supported-version";
private static final String KEY_ENFORCE = "aiimage.client-version.enforce";
private static final String KEY_REJECT_UNREPORTED = "aiimage.client-version.reject-unreported";
/** {@code ${ENV:默认}} 形状;只取默认段,这样测试判的是<b>出厂值</b>,不受跑测试的机器上的环境变量影响。 */
private static final Pattern PLACEHOLDER = Pattern.compile("^\\$\\{([^:}]+):([^}]*)\\}$");
private final List<String> anchorLines = new ArrayList<>();
// ---------------------------------------------------------------- 1. 三键真的存在
@Test
void threeFloorKeysShipInsideApplicationYml() {
Map<String, String> flat = flatten("application.yml");
assertThat(flat.keySet())
.as("三键必须都在 application.yml 里(缺一个就又是出厂即惰性)")
.contains(KEY_MIN, KEY_ENFORCE, KEY_REJECT_UNREPORTED);
assertThat(shippedDefault(flat, KEY_MIN)).isEqualTo("4.0.47");
assertThat(shippedDefault(flat, KEY_ENFORCE)).isEqualTo("false");
assertThat(shippedDefault(flat, KEY_REJECT_UNREPORTED)).isEqualTo("false");
}
@Test
void shippedFloorIsANumberTheGateCanActuallyParse() {
// 地板写成 "v4.0" / "4.x" 这类形状时闸门只记账不拒,等于配了个假地板——这里把出厂值验到能解析
Map<String, String> flat = flatten("application.yml");
String min = shippedDefault(flat, KEY_MIN);
long[] parsed = ClientVersionGuardFilter.parse(min);
assertThat(parsed).as("出厂地板 " + min + " 必须解析成数字段").isNotNull();
assertThat(parsed).containsExactly(4L, 0L, 47L);
// 4.0.46(不报版本的上一个包)在地板之下,4.0.48(现网最新包)在地板之上
assertThat(ClientVersionGuardFilter.compare(ClientVersionGuardFilter.parse("4.0.46"), parsed))
.as("4.0.46 必须被判成低于地板,否则记账桶永远是空的").isNegative();
assertThat(ClientVersionGuardFilter.compare(ClientVersionGuardFilter.parse("4.0.48"), parsed))
.as("现网最新的 4.0.48 不能落在地板之下").isPositive();
}
@Test
void otherProfilesDoNotBlankTheFloor() {
// server profile 里若把地板覆盖成空串,打包上去了就等于把闸门关掉——这不允许悄悄发生
for (String file : List.of("application-server.yml")) {
Map<String, String> flat = flatten(file);
String min = flat.get(KEY_MIN);
if (min != null) {
assertThat(shippedDefault(flat, KEY_MIN))
.as(file + " 把地板覆盖成了空值 = 关掉闸门")
.isNotEmpty();
}
}
}
// ---------------------------------------------------------------- 2. 记账模式真的在记账
@Test
void accountingModeRecordsOldClientWithoutTouchingResponse() throws Exception {
SimpleMeterRegistry registry = new SimpleMeterRegistry();
ClientVersionGuardFilter filter = filter("4.0.47", false, false, registry);
ListAppender<ILoggingEvent> captured = capture();
try {
MockHttpServletRequest request = clientRequest("4.0.40");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
// 记账 = 留痕 + 放行,两件事都得判:只判"放行了"就退化成"这个过滤器没干活"
assertThat(chain.getRequest())
.as("enforce=false 必须原样放行到业务")
.isSameAs(request);
assertThat(response.getStatus()).isEqualTo(200);
assertThat(response.getContentAsString())
.as("记账模式下响应体一个字节都不许多")
.isEmpty();
assertThat(counterValue(registry, "below", "4.0.40"))
.as("低于地板的版本必须进 below 桶")
.isEqualTo(1L);
assertThat(messages(captured))
.as("记账必须留下一条能 grep 的 WARN")
.anySatisfy(line -> assertThat(line)
.contains("[版本地板]")
.contains("自报版本=4.0.40")
.contains("verdict=below")
.contains("enforce=false")
.contains("记账模式,暂不拒绝"));
} finally {
release(captured);
registry.close();
}
}
@Test
void unreportedLegacyClientGoesToItsOwnBucketNotBelow() throws Exception {
SimpleMeterRegistry registry = new SimpleMeterRegistry();
ClientVersionGuardFilter filter = filter("4.0.47", false, false, registry);
try {
// 4.0.46 及更早压根不发 X-Client-Version:它们进 unreported 桶,不冒充"低于地板"
MockHttpServletRequest request = clientRequest(null);
filter.doFilter(request, new MockHttpServletResponse(), new MockFilterChain());
// 没报版本时版本标签归一成 unknown(空串当标签会把同一批装机拆成看不见的两桶)
assertThat(counterValue(registry, "unreported", "unknown")).isEqualTo(1L);
assertThat(registry.find(ClientVersionGuardFilter.METRIC).tag("verdict", "below").counter())
.as("没报版本不能记进 below 桶")
.isNull();
} finally {
registry.close();
}
}
@Test
void defaultConfigCannotRejectAnyoneEvenWhenUnreportedFlagIsOn() throws Exception {
// 出厂 enforce=false 时,reject-unreported=true 也不该挡任何请求——拒绝动作只由 enforce 决定
ClientVersionGuardFilter filter = filter("4.0.47", false, true, null);
MockHttpServletRequest request = clientRequest(null);
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, new MockHttpServletResponse(), chain);
assertThat(chain.getRequest()).as("enforce=false 是唯一的总闸,谁都越不过它").isSameAs(request);
}
// ---------------------------------------------------------------- 3. 缺失/惰性态启动可见
@Test
void blankFloorIsLoudAtStartupNotSilentlyInert() {
ListAppender<ILoggingEvent> captured = capture();
try {
filter("", false, false, null).reportFloorState();
assertThat(messages(captured))
.as("地板被留空 = 闸门惰性,必须点名说清楚,不能和「这个功能不存在」长得一样")
.anySatisfy(line -> assertThat(line)
.contains("[版本地板]")
.contains("min-supported-version 未配置")
.contains("闸门惰性"));
assertThat(captured.list)
.as("这条自述得是 WARN 级,INFO 在生产日志级别下会被淹掉")
.allSatisfy(event -> assertThat(event.getLevel().toString()).isEqualTo("WARN"));
} finally {
release(captured);
}
}
@Test
void accountingModeAnnouncesItselfAtStartup() {
ListAppender<ILoggingEvent> accounting = capture();
ListAppender<ILoggingEvent> enforcing;
try {
// 出厂默认(4.0.47 / false / false)启动时把三键状态原样报出来,运维不用猜
filter("4.0.47", false, false, null).reportFloorState();
assertThat(messages(accounting))
.anySatisfy(line -> assertThat(line)
.contains("[版本地板]")
.contains("最低支持版本=4.0.47")
.contains("enforce=false")
.contains("记账模式")
.contains("rejectUnreported=false"));
} finally {
release(accounting);
}
// 同一支方法在 enforce=true 时得改口说「真拒绝」——只测一半就等于自述不可信
enforcing = capture();
try {
filter("4.0.47", true, true, null).reportFloorState();
assertThat(messages(enforcing))
.anySatisfy(line -> assertThat(line)
.contains("enforce=true")
.contains("真拒绝")
.contains("rejectUnreported=true"));
} finally {
release(enforcing);
}
}
@Test
void unparsableFloorIsNamedAtStartup() {
ListAppender<ILoggingEvent> captured = capture();
try {
filter("v4.0", false, false, null).reportFloorState();
assertThat(messages(captured))
.as("配置写坏(v4.0 解析不出数字段)要说出来,否则永远只记 unparsable 还没人知道")
.anySatisfy(line -> assertThat(line)
.contains("[版本地板]")
.contains("解析不出数字段")
.contains("v4.0"));
} finally {
release(captured);
}
}
// ---------------------------------------------------------------- 助手
private ClientVersionGuardFilter filter(String minVersion, boolean enforce, boolean rejectUnreported,
SimpleMeterRegistry registry) {
ClientVersionGuardFilter filter = new ClientVersionGuardFilter(
new com.fasterxml.jackson.databind.ObjectMapper(), registry);
ReflectionTestUtils.setField(filter, "minSupportedVersion", minVersion);
ReflectionTestUtils.setField(filter, "enforce", enforce);
ReflectionTestUtils.setField(filter, "rejectUnreported", rejectUnreported);
return filter;
}
private MockHttpServletRequest clientRequest(String reportedVersion) {
MockHttpServletRequest request = new MockHttpServletRequest("POST", "/api/publish/tasks");
if (reportedVersion != null) {
request.addHeader(ClientVersionGuardFilter.HEADER, reportedVersion);
}
return request;
}
private long counterValue(SimpleMeterRegistry registry, String verdict, String version) {
Counter counter = registry.find(ClientVersionGuardFilter.METRIC)
.tag("verdict", verdict).tag("version", version).counter();
return counter == null ? 0L : (long) counter.count();
}
private ListAppender<ILoggingEvent> capture() {
Logger logger = (Logger) LoggerFactory.getLogger(ClientVersionGuardFilter.class);
ListAppender<ILoggingEvent> appender = new ListAppender<>();
appender.start();
logger.addAppender(appender);
return appender;
}
private void release(ListAppender<ILoggingEvent> appender) {
((Logger) LoggerFactory.getLogger(ClientVersionGuardFilter.class)).detachAppender(appender);
}
private List<String> messages(ListAppender<ILoggingEvent> appender) {
return appender.list.stream().map(ILoggingEvent::getFormattedMessage).toList();
}
/** 读打进 classpath 的那份 yml({@code src/main/resources} 会被拷进 target/classes),读不到就红。 */
private Map<String, String> flatten(String fileName) {
ClassPathResource resource = new ClassPathResource(fileName);
assertThat(resource.exists())
.as("classpath 上找不到 " + fileName + " —— 判据读不到出厂配置就是空转")
.isTrue();
try (InputStream in = resource.getInputStream()) {
Map<String, String> flat = new LinkedHashMap<>();
for (PropertySource<?> source : new YamlPropertySourceLoader().load(fileName, resource)) {
if (source instanceof EnumerablePropertySource<?> enumerable) {
for (String name : enumerable.getPropertyNames()) {
Object value = enumerable.getProperty(name);
flat.put(name, value == null ? "" : String.valueOf(value));
}
}
}
assertThat(flat).as(fileName + " 解析出来的键数(0 就是解析坏了)").isNotEmpty();
return flat;
} catch (Exception e) {
throw new IllegalStateException("读 " + fileName + " 失败", e);
}
}
/** 取 {@code ${ENV:默认}} 的默认段;没占位符就按字面值返回。 */
private String shippedDefault(Map<String, String> flat, String key) {
assertThat(flat)
.as("三键缺一即判红(出厂即惰性的老坑)")
.containsKey(key);
String raw = flat.get(key).trim();
Matcher m = PLACEHOLDER.matcher(raw);
return m.matches() ? m.group(2).trim() : raw;
}
}