后端(四面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:
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
+269
@@ -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;
|
||||
}
|
||||
}
|
||||
+326
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
+233
@@ -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>文件名 -> 判定不该接的原因</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");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user