feat(菜单权限): 每家公司一套菜单树(V149)+ 公司 tab 只在注册表页渲染

本批两件事,加上随本批一起入仓的并行会话在制品:

一、菜单权限按公司隔离(批次 6)
- V149 给 columns 加 company_id:先可空加列(末位、ALGORITHM=INSTANT)→ 回填公司 1 →
  MODIFY 收紧 NOT NULL;三段式缺一即撞 1048。同时建 (company_id, column_key) 复合键、
  把公司 2 的 16 笔授权按 column_key 改指向它自己的副本,三类 menu_type 全复制,
  admin_companies 作为角色内生闸门行不复制(D3)。
- 第三道归属门 PermissionMenuService.resolveScopeCompanyId:站点超管可带 company_id
  读写任意公司,非超管锁本公司、越界 403。它注册进 CompanyIdParamGoesThroughReadScopeTest
  的 SCOPE_DOORS,四条判据与 readScope / readCompanyIdOrOwn 共用——护栏在代码出口,不靠清单。
- 旁路种子 PermissionMenuSchemaInitializer 只种公司 1:31 段种子逐条钉公司,
  按 column_key 点查的 14 段全部带 company_id,否则摘了 DEFAULT 就是跨公司串写。
- CompanyService.create 同一次写入里给新公司复制模板树(D4)。

二、公司 tab 收口(批次 b)
tab 条挂在壳层,对 22 页全画;改为按正列表 companyTabAppliesTo(menuKey) 判定,
只有注册表页渲染。护栏钉在用户看见的那个出口。

三、并行会话在制品(控制方「全部提交」,未单独拆分——见下)
- V150 店铺密钥 biz_shop_key 按公司(readCompanyIdOrOwn + writeCompanyId 两道门)
- V151 品牌库/商品类目推翻为全平台共享:只退唯一键、company_id DEFAULT 保留为
  NOT NULL 承重约束(摘了每条 1364);删掉 ProductCategoryControllerCompanyScopeTest
  那支"按公司隔离"的旧护栏,readCompanyId 方法一并移除
- invalidasin 字段与外观专利合批的连带改动

为什么不拆笔:后端 3891 例 / 0 红、前端 1731 例 / 0 红这两个读数是"合起来的树"的读数,
拆成多笔会让每一笔落到从未一起验过的组合上,而这一版要直接上两台。

回滚脚本在 backend-java/docs/rollback-V149/V150/V151-*.sql,不放进 Flyway 扫描路径。
设计记录:docs/ops/menu-company-tree-design-2026-10-06.md
This commit is contained in:
2026-10-06 17:17:14 +08:00
parent e635fa8dcd
commit b7acfc0eef
84 changed files with 5118 additions and 1421 deletions
@@ -326,18 +326,56 @@ class CompanyScopeMigrationV145Test {
}
/**
* 破坏点:头注释喊了哨兵,哨兵却没探这两列 ⇒ "有人盯着摘 DEFAULT"这件事是假的。
* 破坏点:头注释喊了哨兵,哨兵却没探这一列 ⇒ "有人盯着摘 DEFAULT"这件事是假的。
* 这条把文档承诺与代码实现对齐(§10 护栏 1 的可执行部分)。
*
* <p>2026-10-06 口径变更后,本用例的"对齐对象"从 V145 的头注释移到了 V151 的头注释——
* 那一笔才是现在的说法。两张表在这里分道:{@code biz_dedupe_total_data} 仍每公司一套,
* DEFAULT 的倒计时还在;{@code biz_invalid_asin_data} 随「全平台共享」定案<b>退出</b>哨兵清单,
* 它的 DEFAULT 从"待摘"翻转成 {@code NOT NULL} 的承重约束(新 jar 的 INSERT 不带这一列,
* 靠默认值填)。所以这一支既要钉它真的不在了,也要钉"不在"这件事在版本化的迁移注释里有据可查——
* 否则下一个人会照本文件头注释的旧承诺去执行 {@code DROP DEFAULT},把每次写入变成 1364。</p>
*/
@Test
void startupSentinelActuallyWatchesTheTwoNewColumns() throws IOException {
Path guard = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
assertTrue(Files.isRegularFile(guard), "启动期 DEFAULT 哨兵应存在:" + guard);
String text = raw(guard);
void startupSentinelStillWatchesDedupeAndV151RecordsWhyTheSharedOneLeft() throws IOException {
Path guardFile = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
assertTrue(Files.isRegularFile(guardFile), "启动期 DEFAULT 哨兵应存在:" + guardFile);
String text = raw(guardFile);
assertTrue(text.contains("COMPANY_DEFAULT_STILL_PRESENT"), "哨兵标记串必须保持 ASCII 原样(巡检按它 grep docker logs)");
assertTrue(text.contains("'" + INVALID + "'"), "哨兵要探品牌库的 company_id,否则 V145 的 DEFAULT 没人盯");
assertTrue(text.contains("'" + DEDUPE + "'"), "哨兵要探去重库的 company_id");
assertTrue(text.contains("COLUMN_DEFAULT"), "哨兵应真的读列元数据,而不是靠猜");
List<String> watched = probeTables(text);
assertTrue(watched.contains(DEDUPE), "去重库仍按公司:它的 DEFAULT 必须还有人盯");
assertFalse(watched.contains(INVALID),
"品牌库已按「全平台共享」退出哨兵清单,哨兵不该再对它喊 DROP DEFAULT");
String sharedKeyMigration = raw(sharedKeyMigrationFile());
assertTrue(sharedKeyMigration.contains(INVALID),
"V151 的头注释要点名品牌库(它就是为这两张表退键而存在的)");
assertTrue(sharedKeyMigration.contains("1364") && sharedKeyMigration.contains("DROP DEFAULT"),
"退出哨兵的理由必须写在换键那一笔里:不写清 1364,"
+ "本文件头注释那条旧承诺就会让人去摘一个现在摘不得的默认值");
}
/** 取哨兵探针 SQL 的 {@code TABLE_NAME IN ('a', 'b')} 段;只认这一段,别把 {@code 'company_id'} 也算进来。 */
private static List<String> probeTables(String guardSource) {
Matcher inList = Pattern.compile("TABLE_NAME\\s+IN\\s*\\(([^)]*)\\)").matcher(guardSource);
assertTrue(inList.find(), "哨兵源码里没有 TABLE_NAME IN (…) 这一段,取不到清单");
List<String> tables = new ArrayList<>();
Matcher quoted = Pattern.compile("'([^']+)'").matcher(inList.group(1));
while (quoted.find()) {
tables.add(quoted.group(1));
}
assertFalse(tables.isEmpty(), "IN 列表解析出 0 张表 ⇒ contains/assertFalse 两条都会恒真或恒假");
return tables;
}
private static Path sharedKeyMigrationFile() throws IOException {
List<Path> hits = versionFiles().stream()
.filter(p -> p.getFileName().toString().startsWith("V151__"))
.toList();
assertEquals(1, hits.size(), "V151(两张共享表退回全局唯一键)应存在且只有一个:" + hits);
return hits.get(0);
}
/** 破坏点:盘点文档没跟着改,下一个人按"取号起点"取号就撞号。 */
@@ -0,0 +1,553 @@
package com.nanri.aiimage.config;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* V149({@code columns} 从"全平台一棵菜单字典"改成"每家公司一套树")的文件审计。
* 设计:crawler-plugin/docs/ops/menu-company-tree-design-2026-10-06.md;
* 定案三条:D1 同笔迁移重指存量授权、D2 站点超管可带 company_id、D3 不复制 admin_companies。
*
* <p>本仓 pom 无 H2、无 testcontainers,迁移跑不起来,所以文件审计是唯一能守住的层——
* 与 {@link CompanyScopeMigrationV145Test} / {@link ProductCategoryMigrationV147Test} 同口径:
* 断言打在剥掉注释后的可执行 SQL 上,注释里的内容另用 {@link #rawMigration()} 单独钉。</p>
*
* <p>这一版和 V145/V147 最大的不同:它不是"加一列",而是<b>加列 + 换键 + 复制 + 重指授权</b>四件事
* 同批。只做前三件,第 2 家的账号一上线就掉光菜单(隐藏=静默删除);只做加列,
* {@code findDataPermission} 这类"按 column_key 点查 + LIMIT 1"会在同名多行里借位拿到别家的行。
* 所以下面每条破坏点都在问"这四件是不是真的都做完了、而且顺序对"。</p>
*/
class MenuTreeCompanyMigrationV149Test {
private static final Path ROOT = Path.of(System.getProperty("user.dir"));
private static final Path DB_DIR = ROOT.resolve("src/main/resources/db");
private static final String COLUMNS = "columns";
private static final String GRANTS = "user_column_permission";
/** 角色内在闸门那一行:设计定案 D3——唯一不复制的菜单。 */
private static final String GATE_KEY = "admin_companies";
// ---------------------------------------------------------------- 取文件
private static List<Path> versionFiles() throws IOException {
try (Stream<Path> s = Files.list(DB_DIR)) {
return s.filter(p -> p.getFileName().toString().matches("^V\\d+(?:_\\d+)?__.*\\.sql$"))
.sorted()
.toList();
}
}
private static int versionOf(Path p) {
Matcher m = Pattern.compile("^V(\\d+)(?:_\\d+)?__").matcher(p.getFileName().toString());
return m.find() ? Integer.parseInt(m.group(1)) : -1;
}
private static Path migration() throws IOException {
List<Path> hits = versionFiles().stream()
.filter(p -> p.getFileName().toString().startsWith("V149__"))
.toList();
assertFalse(hits.isEmpty(), "缺少 V149__*.sql:菜单树还没按公司分棵");
assertEquals(1, hits.size(), "V149 只允许一个迁移文件(撞号会让两台 java 同时起不来)");
return hits.get(0);
}
private static String raw(Path file) throws IOException {
return Files.readString(file, StandardCharsets.UTF_8);
}
private static String rawMigration() throws IOException {
return raw(migration());
}
private static String statements() throws IOException {
return normalize(stripComments(rawMigration()));
}
// ------------------------------------------------------------ SQL 预处理
// 与 CompanyScopeMigrationV145Test 逐字同实现:注释里的 -- 与字符串里的 -- 是两件事,
// 另写一版简化实现会让断言打在残缺 SQL 上。
private static String stripComments(String sql) {
StringBuilder out = new StringBuilder(sql.length());
int i = 0;
while (i < sql.length()) {
char c = sql.charAt(i);
if (c == '\'') {
int end = i + 1;
while (end < sql.length()) {
if (sql.charAt(end) == '\'') {
if (end + 1 < sql.length() && sql.charAt(end + 1) == '\'') {
end += 2;
continue;
}
break;
}
end++;
}
out.append(sql, i, Math.min(end + 1, sql.length()));
i = end + 1;
continue;
}
if (c == '-' && i + 1 < sql.length() && sql.charAt(i + 1) == '-') {
while (i < sql.length() && sql.charAt(i) != '\n') {
i++;
}
continue;
}
if (c == '/' && i + 1 < sql.length() && sql.charAt(i + 1) == '*') {
int end = sql.indexOf("*/", i + 2);
i = end < 0 ? sql.length() : end + 2;
continue;
}
out.append(c);
i++;
}
return out.toString();
}
private static String normalize(String sql) {
return sql.replaceAll("\\s+", " ").trim();
}
private static long count(String haystack, String needle) {
long n = 0;
int i = haystack.indexOf(needle);
while (i >= 0) {
n++;
i = haystack.indexOf(needle, i + needle.length());
}
return n;
}
/** 抽出所有形如 {@code ALTER TABLE `x`} 的表名,用于"只动这几张表"的判据。 */
private static List<String> alteredTables(String sql) {
List<String> hits = new ArrayList<>();
Matcher m = Pattern.compile("ALTER TABLE `([a-z_]+)`").matcher(sql);
while (m.find()) {
hits.add(m.group(1));
}
return hits;
}
/**
* 把旁路种子类的源切成"一条种子语句 = 一段":每个 {@code executeQuietly(} /
* {@code executeUpdateQuietly(} 的起点到下一个标记的起点。
* 只在<b>注释已剥、空白已归一</b>的源上切,所以类注释里那句"裸 {@code WHERE column_key = ...}"
* 不会被当成一条种子喂给判据。
*/
private static List<String> seedStatements(String normalizedSource) {
Matcher m = Pattern.compile("execute(?:Update)?Quietly\\(").matcher(normalizedSource);
List<Integer> starts = new ArrayList<>();
List<Integer> bodies = new ArrayList<>();
while (m.find()) {
starts.add(m.start());
bodies.add(m.end());
}
List<String> regions = new ArrayList<>();
for (int i = 0; i < bodies.size(); i++) {
int to = i + 1 < starts.size() ? starts.get(i + 1) : normalizedSource.length();
regions.add(normalizedSource.substring(bodies.get(i), to));
}
return regions;
}
/**
* 一把尺子:一段种子语句里凡按 {@code column_key} 认菜单的(写比较的,不是列清单里那个列名),
* 就必须在同一段里钉住 {@code company_id}。返回"按 key 认菜单却没钉公司"的那些段。
*/
private static List<String> keyLookupsWithoutCompany(List<String> regions) {
List<String> offenders = new ArrayList<>();
for (String region : regions) {
if (region.contains("column_key =") && !region.contains("company_id")) {
offenders.add(region);
}
}
return offenders;
}
// ------------------------------------------------------------------ 用例
/** 破坏点:取到已应用的号(原地改=两台都起不来),或者根本没落盘。 */
@Test
void migrationIsVersionedOneFourNine() throws IOException {
Path file = migration();
assertEquals(149, versionOf(file), "本迁移必须是 V149");
assertTrue(file.getFileName().toString().matches("^V149__[A-Za-z0-9_.-]+\\.sql$"),
"命名应 V149__<snake 描述>.sql:" + file.getFileName());
}
/**
* 破坏点:三段式少任何一段。少回填 ⇒ 第 3 段的 MODIFY 把存量行撞成 1048;
* 少 MODIFY ⇒ 列可空,"没有归属的行"在任何公司的树上都不出现,而按 key 点查会判成"这个菜单不存在"。
* 加列必须走<b>末位</b>(不许出现 {@code AFTER}):非末位加列能不能 INSTANT 取决于生产 MySQL 小版本,
* 押错了是发版窗口第 1 段直接 1846,而这一列的位置没有任何语义。
*/
@Test
void companyColumnIsAppendedBackfilledThenTightened() throws IOException {
String sql = statements();
assertTrue(sql.contains("ALTER TABLE `columns` ADD COLUMN `company_id` bigint NULL COMMENT"),
"第 1 段应先加成可空:" + sql);
assertEquals(1, count(sql, "ALGORITHM = INSTANT"), "只有加列这一条走 INSTANT");
assertEquals(0, count(sql, " AFTER "), "末位加列才配得上 ALGORITHM = INSTANT,不许写 AFTER");
assertTrue(sql.contains("UPDATE `columns` SET `company_id` = 1 WHERE `company_id` IS NULL;"),
"存量归第 1 家必须带 IS NULL 限定(重跑才是 no-op,也不覆盖人工指定过的行)");
assertTrue(sql.contains("ALTER TABLE `columns` MODIFY COLUMN `company_id` bigint NOT NULL DEFAULT 1"),
"第 3 段收成 NOT NULL DEFAULT 1,它同时是回填没跑全的自检闸门(1048)");
assertEquals(1, count(sql, "MODIFY COLUMN `company_id`"), "MODIFY 只许出现在建列定形状这一处");
}
/**
* 破坏点:新键没把 company_id 放第一位,或旧键还在。
* 旧键 {@code uk_column_key} 不摘,第 2 家公司连"和别家同名"的菜单都建不出来——
* 那不是看不到,是建不出,整套改造白做;而先 DROP 后 ADD 的写法会让中间态裸奔,
* 且复制段直接撞旧键的全局唯一(1062)。
*/
@Test
void uniqueKeysAreReplacedNotLayeredAndInThatOrder() throws IOException {
String sql = statements();
assertTrue(sql.contains("ADD UNIQUE KEY `uk_company_column_key` (`company_id`, `column_key`)"), sql);
assertTrue(sql.contains("ADD UNIQUE KEY `uk_company_menu_type_route_path` (`company_id`, `menu_type`, `route_path`)"), sql);
assertTrue(sql.contains("DROP INDEX `uk_column_key`"), "旧的全局键必须摘,否则第二棵树建不出来");
assertTrue(sql.contains("DROP INDEX `uk_menu_type_route_path`"), "路径的全局键同理");
assertTrue(sql.indexOf("ADD UNIQUE KEY `uk_company_column_key`") < sql.indexOf("DROP INDEX `uk_column_key`"),
"顺序必须是先 ADD 后 DROP:中间任一步失败都还剩一个唯一键在守并发");
assertTrue(sql.indexOf("ADD UNIQUE KEY `uk_company_menu_type_route_path`") < sql.indexOf("DROP INDEX `uk_menu_type_route_path`"));
// 复制段(第 6 段)排在两条旧键摘掉之后,否则它撞的就是旧键。
assertTrue(sql.indexOf("DROP INDEX `uk_column_key`") < sql.indexOf("INSERT INTO `columns`"),
"换键必须早于复制段");
assertEquals(4, count(sql, "ALGORITHM = INPLACE, LOCK = NONE"),
"四条索引操作都要钉 INPLACE+LOCK=NONE,否则 MySQL 可以选 COPY 锁写");
}
/**
* 破坏点:驱动集硬编码"公司 2"。第三家开通时就得再发一版迁移。
* 破坏点 2:把 {@code admin_companies} 也复制了——它是角色内在闸门(Java 的 SUPER_ADMIN_ONLY_KEYS
* 与前端 SUPER_ADMIN_ONLY_MENU_KEYS 同值),别家树里有这一行只会多一个"谁也授不出去"的摆设。
*/
@Test
void copyIsDrivenByTheCompanyTableAndSkipsTheRoleIntrinsicGate() throws IOException {
String sql = statements();
assertTrue(sql.contains("FROM `company` co"), "复制段的驱动集应是 company 全表,不是写死一个公司 id");
assertTrue(sql.contains("JOIN `columns` src ON src.company_id = 1"), "源树固定取公司 1");
assertTrue(sql.contains("WHERE co.id <> 1"), "对【所有】非 1 的公司做(含 status=0,少一家树就少一次启用检查)");
assertTrue(sql.contains("AND src.column_key <> 'admin_companies'"),
"定案 D3:admin_companies 不复制");
assertTrue(sql.contains("AND NOT EXISTS ("), "复制段必须幂等(repair 重跑不插第二份)");
assertEquals(1, count(sql, "INSERT INTO `columns`"), "本迁移只有一条插菜单行的语句");
}
/**
* 破坏点:副本照抄源行的 parent_id。那是全局 id,会把别家的子页面挂到厦门米椿花的分组下——
* 而 {@code fk_columns_parent_id} 只保证父行【存在】,挡不住跨公司挂父,库侧不会喊。
* 所以插入时父必须留 NULL,再按 (company_id, column_key) 认父。
*/
@Test
void copiesReparentByColumnKeyNeverById() throws IOException {
String sql = statements();
assertTrue(sql.contains("SELECT co.id, src.name, src.column_key, src.menu_type, src.route_path, src.sort_order, NULL, src.created_at"),
"插入段的 parent 位置必须是字面 NULL:" + sql);
assertTrue(sql.contains("JOIN `columns` pcopy ON pcopy.company_id = copy.company_id AND pcopy.column_key = sp.column_key"),
"认父要沿 (company_id, column_key) 走");
assertTrue(sql.contains("SET copy.parent_id = pcopy.id"));
assertTrue(sql.contains("AND copy.parent_id IS NULL"), "重跑时已认过父的行不再改动");
assertEquals(1, count(sql, "SET copy.parent_id"), "认父只有一条语句");
}
/**
* 破坏点:第 8 段(去重)没跑就先重指。同一账号若同时挂着源行与副本,重指会撞
* {@code (user_id, column_id)} 主键报 1062 —— 而这条只在 repair 重跑那种中途态才可能出现,
* 所以它必须写在重指之前,而不是"反正今天 0 行"。
*/
@Test
void duplicateGrantsArePrunedBeforeTheRepoint() throws IOException {
String sql = statements();
assertTrue(sql.contains("DELETE dup FROM `user_column_permission` dup"), "缺第 8 段的重指在重跑时会撞 1062");
assertTrue(sql.indexOf("DELETE dup FROM") < sql.indexOf("UPDATE `user_column_permission` g"),
"去重必须排在重指之前");
assertEquals(1, count(sql, "DELETE dup FROM"), "去重只删副本那一侧,且只此一处");
}
/**
* 破坏点(定案 D1 的核心):只复制树不重指授权。存量 784 笔里公司 2 那 16 笔仍挂在
* 公司 1 的行上,而读侧改成"只认本公司"之后,德阳的 2 只账号一上线掉光菜单——
* 这是"隐藏=静默删除"的同一类事故,所以它必须是同笔迁移的动作而不是发布后的人工待办。
*/
@Test
void existingGrantsAreRepointedToTheOwnCompanyCopy() throws IOException {
String sql = statements();
assertTrue(sql.contains("UPDATE `user_column_permission` g"), "第 9 段:存量授权重指向本公司副本");
assertTrue(sql.contains("JOIN `columns` copy ON copy.company_id = u.company_id AND copy.column_key = src.column_key"),
"认行按 column_key,不按 id 猜");
assertTrue(sql.contains("SET g.column_id = copy.id"));
assertTrue(sql.contains("WHERE u.company_id <> 1"),
"驱动条件限定在\"不属于公司 1\",重跑时这一行都选不出来=no-op");
assertEquals(1, count(sql, "SET g.column_id"), "改授权指针只有一条语句");
}
/**
* 破坏点:残留没让它响。四道闸门(临时表 must_be_zero NOT NULL,V143 那个"让约束替我喊"的家族)
* 缺任何一道,对应的失效形状都是"树少一棵 / 父挂错家 / 授权挂别家 / 冒出无归属行"——
* 四条全都不报错,只是某家公司侧边栏空白或按 key 点查判成"菜单不存在"。
*/
@Test
void fourGatesFailTheMigrationOnAnyResidual() throws IOException {
String sql = statements();
assertTrue(sql.contains("CREATE TEMPORARY TABLE IF NOT EXISTS `_v149_gate` (`must_be_zero` INT NOT NULL)"),
"闸门表必须是 NOT NULL 的一列——插 NULL 才抛 1048");
assertEquals(4, count(sql, "INSERT INTO `_v149_gate`"), "四道闸门:齐套性/跨公司父/跨公司授权/无归属行");
assertEquals(4, count(sql, "SELECT IF(COUNT(*) = 0, 0, NULL)"),
"每道都必须是\"计数为 0 才插得进去\"的形状,写成了 SELECT 就永远不为 0");
assertEquals(1, count(sql, "DROP TEMPORARY TABLE `_v149_gate`"), "闸门表用完要删");
// 逐道点名,防"四道其实都探同一件事"
assertTrue(sql.contains("LEFT JOIN `columns` cp ON cp.company_id = co.id AND cp.column_key = src.column_key"),
"闸门 1 要按公司逐行核对齐套");
assertTrue(sql.contains("WHERE c.company_id <> p.company_id"), "闸门 2 探跨公司父");
assertTrue(sql.contains("WHERE c.company_id <> u.company_id"), "闸门 3 探跨公司授权");
assertTrue(sql.contains("WHERE `company_id` IS NULL OR `company_id` <= 0"), "闸门 4 探无归属行");
}
/**
* 破坏点:写成裸 ALTER(不可重跑)。MySQL 的 DDL 不进事务,repair + 重启会从第一条语句重跑整个文件,
* 裸 ALTER 在恢复路径上必撞 1060/1050。
* 计数由本轮扫描得出、不自挑:五条条件 DDL(1 加列 + 2 加键 + 2 摘键)各配一份元数据判断与 PREPARE;
* 唯一不守卫的那条是 MODIFY——它在已 NOT NULL 的列上重跑不报错,属于天生幂等。
*/
@Test
void everyConditionalDdlIsGuardedByInformationSchema() throws IOException {
String sql = statements();
long alters = count(sql, "ALTER TABLE");
assertEquals(6, alters, "本迁移应有 6 条 ALTER(5 条件 + 1 条 MODIFY),实际 " + alters);
assertEquals(alters - 1, count(sql, "PREPARE stmt FROM @sql"), "五条条件 DDL 都要走 PREPARE");
assertEquals(alters - 1, count(sql, "DEALLOCATE PREPARE stmt"), "PREPARE 名复用前必须 DEALLOCATE");
assertEquals(alters - 1, count(sql, "information_schema"), "每条条件 DDL 各自要一次元数据存在性判断");
assertEquals(1, count(sql, "MODIFY COLUMN"), "不守卫的那一条只能是 MODIFY");
}
/** 破坏点:顺手改了 users / company,或建了持久表(菜单树的归属改造只该动这两张表)。 */
@Test
void touchesOnlyTheMenuCatalogAndItsGrants() throws IOException {
String sql = statements();
assertTrue(alteredTables(sql).stream().allMatch(COLUMNS::equals),
"所有 ALTER 都只能打在 columns 上,实际动到了 " + alteredTables(sql));
assertFalse(sql.contains("ALTER TABLE `users`"), "users.company_id 归 V143/V144 管,本迁移只读它");
assertFalse(sql.contains("ALTER TABLE `company`"), "company 表结构不动");
assertFalse(sql.replace("CREATE TEMPORARY TABLE", "").contains("CREATE TABLE"),
"除闸门临时表外不建持久表");
assertTrue(sql.contains("UPDATE `user_column_permission`"), "授权重指是本迁移的第二张写表");
assertEquals(0, count(sql, "DELETE FROM `users`"), "绝不删账号");
}
/** 破坏点:影响面是估的、DEFAULT 的倒计时没人接。锁表结论与摘 DEFAULT 的时点都只有配上实查数才站得住。 */
@Test
void headerCarriesMeasuredVolumesAndTheDefaultCountdown() throws IOException {
String raw = rawMigration();
assertTrue(raw.contains("52 行"), "columns 行数必须是生产实查值");
assertTrue(raw.contains("784") && raw.contains("133"), "授权笔数/账号数必须是生产实查值(重指段的分母)");
assertTrue(raw.contains("admin_companies"), "头注释要写明那一行不复制的理由,否则后人以为漏了");
assertTrue(raw.contains("1048"), "MODIFY 兼作回填自检闸门这件事要写进注释");
assertTrue(raw.contains("1364"), "DEFAULT 1 是为同批旧 jar 存在(旧实体没这列,insert 整列跳过会报它)");
assertTrue(raw.contains("COMPANY_DEFAULT_STILL_PRESENT"),
"摘 DEFAULT 的倒计时由启动期哨兵喊,头注释要点名那条 ASCII 签名");
assertTrue(raw.contains("ALTER COLUMN company_id DROP DEFAULT"),
"要给出摘除的安全写法(纯元数据),否则后人会照 V143 用 MODIFY 重建表");
assertTrue(raw.contains("禁写成 MODIFY"), "下一版摘 DEFAULT 禁 MODIFY 这条要写在文件里");
assertTrue(raw.contains("从第一条语句重跑整个文件"), "可重跑性是恢复路径的前提,注释要写明");
}
/** 破坏点:验证段没核对"各家齐不齐"和"授权还挂不挂在别家"。这两条是上线当晚唯一能证伪的读数。 */
@Test
void shipsPostDeployVerificationSql() throws IOException {
String raw = rawMigration();
assertTrue(raw.contains("SELECT company_id, menu_type, COUNT(*) FROM columns GROUP BY company_id, menu_type"),
"验证 SQL 要按公司×类型数行数");
assertTrue(raw.contains("WHERE c.company_id <> u.company_id"), "验证 SQL 要复验跨公司授权残留");
assertTrue(raw.contains("information_schema.STATISTICS"), "验证 SQL 要复验两条旧键已摘、两条新键在");
}
/**
* 破坏点:回滚被编成版本化迁移(Flyway 扫描路径里的 V*.sql 会在下次启动自动执行),
* 或者回滚把"删副本"排在"重指授权"之前。
*
* <p>后者是这一版独有的陷阱:{@code user_column_permission} 的外键是 ON DELETE CASCADE,
* 先删副本会把它名下授权一起删光——而 V149 之后账号名下"本来就该"挂的是副本行。
* 写反的读数不是报错,是 133 只账号的菜单被清空。</p>
*/
@Test
void rollbackRepointsGrantsBeforeDeletingTheCopiesAndStaysUnversioned() throws IOException {
Pattern writesHistoryTable = Pattern.compile(
"\\b(DELETE|UPDATE|INSERT|TRUNCATE|ALTER|DROP)\\b[^;]*\\bflyway_schema_history\\b",
Pattern.CASE_INSENSITIVE);
for (Path file : versionFiles()) {
String executable = normalize(stripComments(raw(file)));
assertFalse(writesHistoryTable.matcher(executable).find(),
"回滚不许编成版本化迁移:" + file.getFileName() + " 的执行段写了 flyway_schema_history");
}
Path rollback = ROOT.resolve("docs/rollback-V149-permission-menu-company.sql");
assertTrue(Files.isRegularFile(rollback), "回滚人工补丁必须存在:" + rollback);
String whole = raw(rollback);
assertTrue(whole.contains("flyway_schema_history"), "回滚必须删本版本历史行(漏掉=重装时 Flyway 跳过 V149)");
String executable = normalize(stripComments(whole));
assertTrue(executable.contains("SET g.column_id = src.id"), "回滚要先把授权指针挪回公司 1 的源行");
assertTrue(executable.contains("DELETE FROM `columns` WHERE company_id <> 1"), "再删副本");
assertTrue(executable.indexOf("SET g.column_id = src.id") < executable.indexOf("DELETE FROM `columns`"),
"顺序不能反:FK 是 ON DELETE CASCADE,先删副本等于清空 133 只账号的菜单");
assertTrue(whole.contains("ON DELETE CASCADE"), "注释要写明为什么这个顺序是陷阱");
assertTrue(executable.contains("ADD UNIQUE KEY `uk_column_key` (`column_key`)"), "回滚要把两条全平台旧键加回来");
assertTrue(executable.contains("ADD UNIQUE KEY `uk_menu_type_route_path` (`menu_type`, `route_path`)"));
assertTrue(executable.contains("DROP INDEX `uk_company_column_key`"), "并摘掉两条按公司的新键");
assertTrue(executable.contains("DROP INDEX `uk_company_menu_type_route_path`"));
assertTrue(executable.indexOf("ADD UNIQUE KEY `uk_column_key`") < executable.indexOf("DROP INDEX `uk_company_column_key`"),
"回滚同样是先 ADD 后 DROP:中间态必须还剩一个唯一键");
assertTrue(executable.contains("CREATE TEMPORARY TABLE `_v149_rb_gate`"),
"重指与删除之间要有闸门:漏一行就会被 CASCADE 静默吞掉");
assertTrue(executable.contains("CREATE TABLE IF NOT EXISTS `columns_bak_v149_rollback`"),
"删副本前必须整表留底");
}
/**
* 破坏点:头注释喊了哨兵,哨兵却没探这一列 ⇒ "有人盯着摘 DEFAULT"这件事是假的。
* 这条把文档承诺与代码实现对齐(V145 同类用例的同口径)。
*/
@Test
void startupSentinelActuallyWatchesTheMenuColumn() throws IOException {
Path guard = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
assertTrue(Files.isRegularFile(guard), "启动期 DEFAULT 哨兵应存在:" + guard);
String text = raw(guard);
assertTrue(text.contains("COMPANY_DEFAULT_STILL_PRESENT"), "哨兵标记串必须保持 ASCII 原样(巡检按它 grep docker logs)");
assertTrue(text.contains("\"columns\""), "哨兵要探 columns.company_id,否则 V149 的 DEFAULT 没人盯");
assertTrue(text.contains("'columns'"), "探针 SQL 的 IN 列表也要含它,只进清单是假盯");
assertTrue(text.contains("COLUMN_DEFAULT"), "哨兵应真的读列元数据,而不是靠猜");
}
/**
* 破坏点:旁路种子(启动期自建表/键的那个初始化器)还按换列之前的全局口径建键。
* 它一旦被执行,新库就会带着 {@code uk_column_key} 起来 ⇒ 第二家公司的树建不出来,
* 而 V149 的 DROP 只在存量库跑过——这条是"不得回流"的反向钉。
*/
@Test
void schemaInitializerKeepsTheCompanyScopedKeys() throws IOException {
Path initializer = ROOT.resolve(
"src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuSchemaInitializer.java");
String text = raw(initializer);
assertTrue(text.contains("UNIQUE KEY uk_company_column_key (company_id, column_key)"),
"建表要直接带复合键");
assertFalse(text.contains("ADD UNIQUE KEY uk_column_key"), "不得再建全局 column_key 键");
assertFalse(text.contains("ADD UNIQUE KEY uk_menu_type_route_path"), "不得再建全局 (menu_type, route_path) 键");
assertFalse(text.contains("company_id BIGINT NULL COMMENT '归属公司:每家公司一套菜单树' AFTER"),
"加列同样是末位追加,INSTANT 不押版本");
assertTrue(text.contains("UPDATE columns SET company_id = 1 WHERE company_id IS NULL"),
"种子路径也要把存量收成 NOT NULL 三段式的第 2 段");
}
/**
* 破坏点:旁路种子(生产默认关,但新库/本地/那条 `permission-schema-init.enabled=true` 的通道会跑)
* 建出来的行没钉公司。V149 之后 {@code column_key} <b>只在单家公司内唯一</b>,这条通道里一句裸
* {@code WHERE column_key = ...} 就是"把每一家的同名行都改一遍"——别家副本的 parent 被拍平、
* 初始授权发给别家的行 id;而 {@code executeQuietly} 把 1048/1062 吞成一行 debug 日志,
* 表现是"某一家一声不响少一套菜单"。
*
* <p>另一层:这里显式写 {@code company_id} 之后,这条通道就不再依赖列上那条 {@code DEFAULT 1},
* 于是待办里那句 {@code ALTER TABLE columns ALTER COLUMN company_id DROP DEFAULT} 落地时
* 不会把这里的建号变成 1364。所以本用例同时钉"列清单带公司"与"投影是真常量 1"。</p>
*
* <p>形状与 {@code PermissionCompanyMenuHiddenTest} 同一套:先证明取样集非空、
* 再证明这把尺子认得出已知的一条违规(否则上面的 0 命中是恒绿)。</p>
*/
@Test
void schemaInitializerSeedsEveryRowIntoTheTemplateCompany() throws IOException {
String src = normalize(stripComments(raw(ROOT.resolve(
"src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuSchemaInitializer.java"))));
List<String> regions = seedStatements(src);
List<String> keyLookups = regions.stream().filter(r -> r.contains("column_key =")).toList();
assertTrue(regions.size() >= 25, "种子语句取样集太小,扫描器多半没切开:" + regions.size());
assertTrue(keyLookups.size() >= 12,
"按 column_key 认菜单的种子语句取样集太小(换键后这类语句只会更多,不会更少):" + keyLookups.size());
assertEquals(count(src, "INSERT INTO columns ("), count(src, "INSERT INTO columns (company_id,"),
"每条 INSERT 的列清单都要显式带 company_id,不许再让列 DEFAULT 兜");
assertTrue(count(src, "INSERT INTO columns (company_id,") >= 6,
"取样集自检:这条通道本就要种 4 个分组 + 18 条菜单 + 2 条 internal,INSERT 语句不该只剩几条");
assertEquals(count(src, "INSERT INTO columns (company_id,"), count(src, "SELECT 1, "),
"每条种子 INSERT 的投影都必须是常量 1(模板公司):换成别的数字就是在往别家插平台默认行");
assertEquals(1, count(src, "data_col.company_id = old_col.company_id"),
"初始授权必须把 data_col 收在 old_col 同一家,否则老账号拿到别家的数据权限行 id");
assertTrue(keyLookupsWithoutCompany(regions).isEmpty(),
"这些种子语句按 column_key 认菜单却没钉公司,等于对每一家各改一遍:" + keyLookupsWithoutCompany(regions));
String scoped = " ( SELECT 1, 'x', 'admin_users' FROM columns WHERE company_id = 1 AND column_key = 'admin_users' ) ";
String bare = " ( SELECT 1, 'x', 'admin_users' FROM columns WHERE column_key = 'admin_users' ) ";
assertEquals(List.of(bare), keyLookupsWithoutCompany(List.of(scoped, bare)),
"尺子自检:一条没钉公司的已知违规必须被抓到,同时已钉公司的那条不许误报");
}
/**
* 破坏点:读侧或写侧编一个"没带公司就回落公司 1"的临时分支。
* 定案是路线甲(V149 与 jar 同批双台),混合窗口里旧 jar 靠列上的 DEFAULT 兜,不需要 Java 侧兜——
* 而 Java 侧一旦有兜底,"忘了传公司"就从 1048/403 变成静默归到第 1 家。
*
* <p>断言形状:先确认扫描器抓得到锚点(0 命中=尺子坏了),再要求三种兜底写法各 0 命中。</p>
*/
@Test
void serviceHasNoFallbackBranchToTheDefaultCompany() throws IOException {
String src = raw(ROOT.resolve(
"src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuService.java"));
assertTrue(src.contains("resolveScopeCompanyId"), "扫描器要能命中归属判据本身,否则下面的 0 命中不作数");
assertEquals(0, count(src, "? 1L"), "不许出现 `x == null ? 1L` 这种回落默认公司");
assertEquals(0, Pattern.compile("\\?\\s*1L\\b").matcher(src).results().count(), "同上,容空格拉写");
assertFalse(src.contains("COMPANY_DEFAULT"), "不许在本类里另立默认公司常量");
}
/**
* 破坏点:目录取数留下"不带公司"的重载。生产上 operator 恒有 companyId,走不到无参那条,
* 于是"跨公司混树"这条路永远只对新代码开放——按方法名精确匹配,不接受 {@code loadMenus(} 这种含二参的宽匹配。
*
* <p>判据用"括号里既无逗号也无嵌套括号"来认单参调用;抓不住的形状是 {@code loadMenus(resolve(a, b))}
* 这种把唯一实参写成调用式的写法。下面那条阳性对照(喂一条已知违规)证明这把尺子不是恒绿的。</p>
*/
@Test
void menuLoadingAlwaysCarriesACompany() throws IOException {
String src = raw(ROOT.resolve(
"src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuService.java"));
for (String method : List.of("loadMenus", "loadRawMenus")) {
Pattern singleArg = Pattern.compile(method + "\\([^(),]*\\)");
assertEquals(1, Pattern.compile("List<PermissionMenuEntity> " + method + "\\(").matcher(src).results().count(),
method + " 只允许一个声明");
assertEquals(0, singleArg.matcher(src).results().count(),
method + " 不许有单参调用/重载:每个取数点都要显式带公司");
assertEquals(1, singleArg.matcher("List<PermissionMenuEntity> rows = " + method + "(companyId);")
.results().count(), "尺子自检:已知的一条单参调用必须被抓到,否则上面的 0 命中不作数");
}
}
/** 破坏点:盘点文档没跟着改,下一个人按"取号起点"取号就撞号。 */
@Test
void inventoryDocTracksV149() throws IOException {
String text = raw(ROOT.resolve("docs/migration-inventory.md"));
assertTrue(text.contains(migration().getFileName().toString()), "盘点文档应记录 V149 文件名");
assertTrue(text.contains("V152"), "盘点文档应记下新的取号起点(V150/V151 已被同批占用)");
// 取号起点是否真等于"当前最大值 + 1"由 MigrationInventoryTest 派生判定,这里不重复钉死字面号。
}
/** 自检:本用例集扫的是真文件,且 normalize 后仍能命中关键串(0 命中的断言是恒绿的)。 */
@Test
void scannedSignaturesAreActuallyPresent() throws IOException {
String sql = statements();
assertTrue(sql.length() > 1000, "剥注释后的 SQL 太短,说明预处理把内容吃掉了:" + sql.length());
assertTrue(count(sql, "ALTER TABLE") > 0 && count(sql, "information_schema") > 0
&& count(sql, "INSERT INTO `columns`") > 0,
"关键签名 0 命中=预处理或文件路径坏了,本类的断言全部不可信");
}
}
@@ -68,13 +68,24 @@ class MigrationInventoryTest {
}
/**
* 已在生产 flyway_schema_history 中占位、但本地文件被改名让位的版本号。
* 生产 131 之后直接装了 134/135(2026-09-25 20:46:16),132/133 从未落库;
* 而 Flyway 未开 out-of-order,把新迁移编号改回 132/133 会导致启动期
* "resolved migration not applied" 失败,所以这个洞只能永久保留、不能回填。
* 后果:新迁移只能取当前最大值之上的号(详见 docs/migration-inventory.md)。
* 不许再被占用的整数版本洞。两条来历不同,得分开记:
*
* <p><b>132/133</b>:已在生产 {@code flyway_schema_history} 中占位、但本地文件被改名让位的版本号。
* 生产 131 之后直接装了 134/135(2026-09-25 20:46:16),132/133 从未落库;而 Flyway 未开
* out-of-order,把新迁移编号改回 132/133 会导致启动期 "resolved migration not applied" 失败,
* 所以这个洞只能永久保留、不能回填。</p>
*
* <p><b>148</b>:{@code V148__product_category_builtin_owned_by_company.sql}(内置类目归还厦门米椿花)
* 从未上线,2026-10-06 控制方点名「商品类目做成共享的,不区分」⇒ 这一版的口径被整体推翻,
* 文件连同 {@code ProductCategoryMigrationV148Test} 与 rollback 补丁一起删掉。
* 与 132/133 不同,把新迁移编号写回 148 在 Flyway 语义上【是】可行的(生产最大值仍是 147)——
* 这里禁它是共树并发的护栏:那一版是另一路会话此刻正在引用的号,删掉的文件可能被再次写出,
* 而同号两个文件会让 Flyway 启动期报 "Found more than one migration with version 148",
* 后果是两台 java 同时起不来。宁可让本用例红,也不把撞号留到运行期发现。</p>
*
* <p>共同后果:新迁移只能取当前最大值之上的号(详见 docs/migration-inventory.md)。</p>
*/
private static final Set<Integer> RETIRED_HOLES = Set.of(132, 133);
private static final Set<Integer> RETIRED_HOLES = Set.of(132, 133, 148);
@Test
void integerVersionsSequentialFromOne() throws IOException {
@@ -6,6 +6,7 @@ import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -231,19 +232,69 @@ class ProductCategoryMigrationV147Test {
}
/**
* 破坏点:V147 的 DEFAULT 1 没进启动期哨兵清单 ⇒ "下一次记得摘"这件事没人喊,
* 而巡检按 {@code COMPANY_DEFAULT_STILL_PRESENT} 这条 ASCII 签名 grep docker logs。
* 破坏点(2026-10-06 起方向相反):类目表随「商品类目做成所有公司共享」的定案<b>退出</b>了启动期
* 哨兵清单,而它现在仍带 {@code DEFAULT 1}——这一列从"待摘的风险"翻转成了 {@code NOT NULL} 的
* 承重约束:新 jar 的 INSERT/UPDATE 列清单都不带 company_id,靠默认值填。
*
* <p>所以这一支钉的是"哨兵必须不再对它喊"。清单与探针 SQL 的 IN 列表<b>两侧都要钉</b>:
* 只摘一侧会重演本类要避免的那两种静默形状——清单里还在、IN 里没有 ⇒ 每次启动报"探不到"的 WARN;
* IN 里还在、清单里没有 ⇒ 查到了却没人判定,而 {@code CompanyDefaultGuardTest} 的双向同源钉
* 会红在那一张"仍按公司"的表上,不会红在这里。</p>
*
* <p>另一半:退出这件事必须在版本化的迁移注释里有据可查。只改代码不改说法,下一个人会照
* 本文件头注释(V147 那一版写的是"记得摘 DEFAULT")或 {@code CompanyDefaultGuard} 给出的
* {@code DROP DEFAULT} 语句去执行,代价是每次写入 1364,而且这张表的失败会直接顶到管理员面前。</p>
*/
@Test
void startupSentinelWatchesTheProductCategoryColumn() throws IOException {
void startupSentinelHasStoppedWatchingTheProductCategoryColumn() throws IOException {
Path guard = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
assertTrue(Files.isRegularFile(guard), "启动期 DEFAULT 哨兵应存在:" + guard);
String text = raw(guard);
assertTrue(text.contains("COMPANY_DEFAULT_STILL_PRESENT"), "哨兵标记串必须保持 ASCII 原样(巡检按它 grep)");
assertTrue(text.contains("'" + TABLE + "'"),
"探针 SQL 的 IN 列表要含 " + TABLE + "(不在 IN 里就查不到这一列,哨兵等于没探)");
assertTrue(text.contains("\"" + TABLE + "\""),
"WATCHED_TABLES 清单要含 " + TABLE + "(查到了却不在清单里,就没人去喊那条签名)");
assertFalse(probeInList(text).contains(TABLE),
"探针 SQL 的 IN 列表不许再有 " + TABLE + ":查到了就等于还要人摘 DEFAULT");
assertFalse(watchedTables(text).contains(TABLE),
"WATCHED_TABLES 清单不许再有 " + TABLE + ":清单才是判定走不走的那一侧");
Path v151 = sharedKeyMigrationFile();
String note = raw(v151);
assertTrue(note.contains(TABLE), "退键那一笔要点名类目表:" + v151.getFileName());
assertTrue(note.contains("DROP DEFAULT") && note.contains("1364"),
"必须写明\"这一版的 DEFAULT 摘不得\"及其后果,否则 V147 头注释那条旧承诺仍然会被执行");
}
/** 取探针 SQL 的 {@code TABLE_NAME IN ('a', 'b')} 段(单引号)。 */
private static List<String> probeInList(String guardSource) {
Matcher inList = Pattern.compile("TABLE_NAME\\s+IN\\s*\\(([^)]*)\\)").matcher(guardSource);
assertTrue(inList.find(), "哨兵源码里没有 TABLE_NAME IN (…) 这一段,取不到清单");
return quotedValues(inList.group(1), "'([^']+)'");
}
/** 取 {@code WATCHED_TABLES = List.of("a", "b")} 那批双引号表名。 */
private static List<String> watchedTables(String guardSource) {
Matcher list = Pattern.compile("WATCHED_TABLES\\s*=\\s*List\\.of\\(([^)]*)\\)").matcher(guardSource);
assertTrue(list.find(), "取不到 WATCHED_TABLES 清单:哨兵源码的形状变了,本用例的尺子要跟着改");
return quotedValues(list.group(1), "\"([^\"]+)\"");
}
/** 解析不出任何一条就当场判红:0 命中会让上面那两条 {@code assertFalse} 恒真。 */
private static List<String> quotedValues(String segment, String quotePattern) {
List<String> values = new ArrayList<>();
Matcher quoted = Pattern.compile(quotePattern).matcher(segment);
while (quoted.find()) {
values.add(quoted.group(1));
}
assertFalse(values.isEmpty(), "从源码段里解析出 0 个表名 ⇒ 这段断言是恒绿的:" + segment);
return values;
}
private static Path sharedKeyMigrationFile() throws IOException {
List<Path> hits = versionFiles().stream()
.filter(p -> p.getFileName().toString().startsWith("V151__"))
.toList();
assertEquals(1, hits.size(), "V151(两张共享表退回全局唯一键)应存在且只有一个:" + hits);
return hits.get(0);
}
/**
@@ -0,0 +1,296 @@
package com.nanri.aiimage.config;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* V150({@code biz_shop_key} 加 company_id)的文件审计。
* 需求:2026-10-06 控制方点名「店铺密钥管理的数据按照公司区分」;设计见迁移文件头 §1–§6。
*
* <p>为什么必须单独有一支:本仓 pom 无 H2、无 testcontainers,迁移跑不起来,文件审计是唯一能守住的那层
* (与 {@link ProductCategoryMigrationV147Test}、{@link CompanyScopeMigrationV145Test} 同口径)。
* V150 的三条关键决定全都"错了不报错":</p>
* <ol>
* <li>历史归属靠加列时记录的 {@code DEFAULT 1},而不是回填——写成可空列或补一条 UPDATE 都改成另一种语义;</li>
* <li>唯一键 {@code uk_ziniao_token_hash} <b>刻意保持全局</b>(不像 V145/V147 那样按公司放宽),
* 谁"顺手把它按公司放宽"就会让同一个令牌在两家公司各存一行、被 {@code ZiniaoApiKeyProvider}
* 按令牌并成一条,白名单状态与代理地址互相顶掉;</li>
* <li>回滚的默认档是<b>保留新列、只回 jar</b>,删列那一步留在注释里由人工解开(这张表没有账号列,
* 列一删归属就再也分不回去)。</li>
* </ol>
*
* <p>{@code stripComments}/{@code normalize} 逐字沿用 {@link CompanyScopeMigrationV145Test} 那一份实现:
* 注释里的 {@code --} 与字符串字面量里的 {@code --} 是两件事,另写一版简化实现会让断言打在残缺 SQL 上。</p>
*/
class ShopKeyMigrationV150Test {
private static final Path ROOT = Path.of(System.getProperty("user.dir"));
private static final Path DB_DIR = ROOT.resolve("src/main/resources/db");
private static final String TABLE = "biz_shop_key";
private static final String GLOBAL_UNIQUE_KEY = "uk_ziniao_token_hash";
// ---------------------------------------------------------------- 取文件
private static List<Path> versionFiles() throws IOException {
try (Stream<Path> s = Files.list(DB_DIR)) {
return s.filter(p -> p.getFileName().toString().matches("^V\\d+(?:_\\d+)?__.*\\.sql$"))
.sorted()
.toList();
}
}
private static Path migration() throws IOException {
List<Path> hits = versionFiles().stream()
.filter(p -> p.getFileName().toString().startsWith("V150__"))
.toList();
assertEquals(1, hits.size(),
"V150 必须恰好一个迁移文件,实际 " + hits.size() + " 个(0 个=密钥表还没归属列;2 个=撞号,Flyway 启动即失败)");
return hits.get(0);
}
private static String raw(Path file) throws IOException {
return Files.readString(file, StandardCharsets.UTF_8);
}
private static String statements() throws IOException {
return normalize(stripComments(raw(migration())));
}
// ------------------------------------------------------------ SQL 预处理
// 与 CompanyScopeMigrationV145Test / ProductCategoryMigrationV147Test 逐字同实现,理由见类注释。
private static String stripComments(String sql) {
StringBuilder out = new StringBuilder(sql.length());
int i = 0;
while (i < sql.length()) {
char c = sql.charAt(i);
if (c == '\'') {
int end = i + 1;
while (end < sql.length()) {
if (sql.charAt(end) == '\'') {
if (end + 1 < sql.length() && sql.charAt(end + 1) == '\'') {
end += 2;
continue;
}
break;
}
end++;
}
out.append(sql, i, Math.min(end + 1, sql.length()));
i = end + 1;
continue;
}
if (c == '-' && i + 1 < sql.length() && sql.charAt(i + 1) == '-') {
while (i < sql.length() && sql.charAt(i) != '\n') {
i++;
}
continue;
}
if (c == '/' && i + 1 < sql.length() && sql.charAt(i + 1) == '*') {
int end = sql.indexOf("*/", i + 2);
i = end < 0 ? sql.length() : end + 2;
continue;
}
out.append(c);
i++;
}
return out.toString();
}
private static String normalize(String sql) {
return sql.replaceAll("\\s+", " ").trim();
}
// ------------------------------------------------------------------ 用例
/** 破坏点:取到已应用的号(原地改=两台都起不来),或把这一版编成 V152(V150 就被跳开,归属列永远不加)。 */
@Test
void migrationIsVersionedOneFiveZero() throws IOException {
Path file = migration();
Matcher m = Pattern.compile("^V(\\d+)(?:_\\d+)?__").matcher(file.getFileName().toString());
assertTrue(m.find(), "文件名应能抽出整数版本:" + file.getFileName());
assertEquals(150, Integer.parseInt(m.group(1)), "本迁移必须是 V150(V149 之后的下一号)");
assertTrue(file.getFileName().toString().matches("^V150__[A-Za-z0-9_.-]+\\.sql$"),
"命名应 V150__<snake 描述>.sql:" + file.getFileName());
}
/**
* 破坏点 ①:加成可空 ⇒ 混合窗口里旧 jar 写进来的密钥行 {@code company_id} 为 NULL,
* 而 {@code applyCompanyScope} 的 null 分支是「不裁剪」,这些行会同时出现在每一家的 tab 上。
* 破坏点 ②:写 {@code MODIFY COLUMN} ⇒ 重建表并按"当时的列默认值"物化历史行,而本迁移没写回历史行,
* 历史归属的全部依据就是加列那一刻记录的默认值(§6)。
* 破坏点 ③:加 {@code AFTER} ⇒ 非末位列在 InnoDB 里要重建聚簇记录,INSTANT 的前提没了。
* {@code DEFAULT 1} 必须<b>在场</b>:它是同批旧 jar 唯一能插进这张表的通道,摘它的是下一版。
*/
@Test
void addsANotNullCompanyColumnWithInstantAndNeverModify() throws IOException {
String sql = statements();
assertTrue(sql.contains("ALTER TABLE `" + TABLE + "` ADD COLUMN `company_id` bigint NOT NULL DEFAULT 1"),
TABLE + " 应一次到位加成 NOT NULL DEFAULT 1(DEFAULT 只为同批旧 jar 存在,摘除是下一版)");
assertTrue(sql.contains("ALGORITHM = INSTANT"),
"加列必须钉 INSTANT:前提不成立时 MySQL 直接报 1846,而不是悄悄退化成 COPY(§3)");
assertFalse(sql.toUpperCase().contains(" AFTER "), "不许写 AFTER:非末位列加列会触发整表重建(§3)");
assertFalse(sql.contains("MODIFY COLUMN"), "禁 MODIFY COLUMN——它会重建表并按当时的默认值物化历史行(§6)");
assertFalse(sql.contains("ALTER TABLE `" + TABLE + "` DROP COLUMN"), "本版本不删列:归属一旦删掉就再也分不出是第几家公司(§2)");
}
/**
* 列注释里那句「历史行由本默认值给出,不可反推」是这一列存在理由的一半:
* 它跟着 schema 走,将来接手的人不必翻迁移文件就知道第 1 家的行里混着窗口期的别家数据。
*/
@Test
void columnCommentCarriesTheProvenanceLimitation() throws IOException {
String sql = statements();
assertTrue(sql.contains("本表无账号列"), "列注释要写明「本表无账号列」,否则后来人会试图按创建人反推归属");
assertTrue(sql.contains("不可反推"), "列注释要写明历史归属「不可反推」,这是 §2 那个不可追回窗口的落点");
}
/**
* 破坏点:有人"顺手"补一条回填 UPDATE(这张表没有账号列,任何"按人回填"都是编数据);
* 或者加了 created_by_id / 二级索引,把"刻意不做的事"做成了既成事实。
* 计数取 0 而不是「不超过 1」:§2 的口径是历史行的 1 来自默认值,一条 DML 都不该有。
*/
@Test
void writesNoDmlAtAllAndAddsNoIndex() throws IOException {
String sql = statements();
Matcher d = Pattern.compile("\\b(UPDATE|INSERT|DELETE|REPLACE)\\b", Pattern.CASE_INSENSITIVE).matcher(sql);
int hits = 0;
while (d.find()) {
hits++;
}
assertEquals(0, hits, TABLE + " 的可执行段一条 DML 都不该有,实际命中 " + hits + " 条 DML 关键字");
assertFalse(sql.contains("created_by_id"), "本版本不加 created_by_id:归属从本版本起由 service 显式落,反推那条路用不上(§2)");
assertEquals(0, count(sql, "ADD INDEX") + count(sql, "ADD KEY"),
"本版本不加二级索引:这张表是「一个紫鸟账号一行」量级,多挂一个单列索引就是 V139 那轮清掉的冗余形状");
}
/**
* 唯一键必须一动不动(§4)。这是本迁移与 V145/V147 最大的口径差别,所以钉成"可执行段里
* 没有任何索引动作",而不是"索引动作少"——放宽那一步一旦发生,运行期的表现是两行并成一行、
* 代理与白名单状态跨公司互相顶掉,不会有任何报错。
*/
@Test
void uniqueKeyStaysGlobalAndTheReasonTravelsWithTheFile() throws IOException {
String sql = statements();
assertEquals(0, count(sql, "DROP INDEX") + count(sql, "ADD UNIQUE KEY"),
"本版本不许动任何索引:uk_ziniao_token_hash 刻意保持全平台唯一(§4)");
assertFalse(sql.contains(GLOBAL_UNIQUE_KEY),
"可执行段里不该出现 " + GLOBAL_UNIQUE_KEY + "(它只应出现在解释为什么不动的注释里)");
String whole = raw(migration());
assertTrue(whole.contains(GLOBAL_UNIQUE_KEY), "「为什么不动唯一键」的理由必须写在迁移文件里,而不是只写在评审意见里");
assertTrue(whole.contains("ZiniaoApiKeyProvider"), "理由的关键环是令牌聚合那一步:注释要点名 ZiniaoApiKeyProvider");
}
/**
* 破坏点:删掉存在性守卫 ⇒ DDL 不进事务,中途失败后按「repair → 重启」重跑会撞 1060(重复列)而彻底起不来。
* 计数取 1 而不是「大于 0」:本文件的可执行段恰好查一次 information_schema(只查列),
* 多一次说明有人加了没登记的索引/键动作,少一次就是守卫没了。
*/
@Test
void addColumnIsGuardedByExistenceCheckAndReRunnable() throws IOException {
String sql = statements();
assertEquals(1, count(sql, "information_schema"),
"可执行段应查 1 次 information_schema(列存在性),实际次数见消息");
assertTrue(sql.contains("TABLE_NAME = '" + TABLE + "'"), "加列的守卫要按本表查");
assertTrue(sql.contains("COLUMN_NAME = 'company_id'"), "加列的守卫要按列名查");
assertTrue(count(sql, "PREPARE stmt FROM @sql") == 1 && count(sql, "EXECUTE stmt") == 1
&& count(sql, "DEALLOCATE PREPARE stmt") == 1,
"条件 DDL 必须走 PREPARE/EXECUTE 并收口(MySQL 不能在 IF 里直接写 DDL)");
}
/**
* 行数今天没实查(§2 写明),取证命令与不可追回窗口必须留在文件里。
* 这一支钉的是"取证责任没被写成既成事实":文件里出现"行数已确认"这类话就是把它编完了。
*/
@Test
void unprobedRowCountStaysAnExplicitDebtWithTheProbeQuery() throws IOException {
String whole = raw(migration());
assertTrue(whole.contains("SELECT COUNT(*) AS total"),
"§2 要带上可实跑的取证 SQL,而不是只留一句「上线前查一下」");
assertTrue(whole.contains("2026-10-04 14:55"), "不可追回窗口的锚点是第二家公司开通时刻,必须在文件里");
assertTrue(whole.contains("没有实查") || whole.contains("未实查"), "行数没查过这件事必须写在文件里,不许读成已知");
}
/**
* 回滚是人工补丁,且在 Flyway 扫描路径之外。
*
* <p>本迁移的回滚默认档<b>一条 SQL 都不执行</b>:这张表没有账号列,删列就删掉了唯一的归属依据,
* 所以 {@code DROP COLUMN} 留在注释里由人工解开,止损走"保留新列、只回 jar"那一档
* (新列对旧 jar 是惰性的,{@code DEFAULT 1} 正好把旧 jar 插入的行接住)。
* {@link CompanyScopeMigrationV145Test#rollbackStaysOutOfFlywayScanAndCoversTheHistoryRow} 按全目录
* 钉"回滚不得版本化",本类只钉本迁移这一支的内容。</p>
*/
@Test
void rollbackIsAHumanPatchThatDefaultsToKeepingTheColumn() throws IOException {
Path doc = ROOT.resolve("docs/rollback-V150-shop-key-company.sql");
assertTrue(Files.isRegularFile(doc), "V150 的人工回滚补丁必须存在:" + doc);
String whole = raw(doc);
assertTrue(whole.contains("flyway_schema_history"), "回滚必须写明删 version='150' 的历史行");
assertTrue(whole.contains("'150'"), "回滚补丁要点名本版本号,后来人才知道删的是哪一行");
String executable = normalize(stripComments(whole));
assertTrue(executable.isEmpty(),
"默认档不执行任何 SQL(删列是不可逆动作,必须留在注释里由人工解开),实际可执行段:" + executable);
assertTrue(whole.contains("DROP COLUMN"), "删列那一步要在文件里,只是不许默认可执行");
}
/**
* 破坏点:V150 的 DEFAULT 1 没进启动期哨兵清单 ⇒ "下一次记得摘"这件事没人喊,
* 而巡检按 {@code COMPANY_DEFAULT_STILL_PRESENT} 这条 ASCII 签名 grep docker logs。
*/
@Test
void startupSentinelWatchesTheShopKeyColumn() throws IOException {
Path guard = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
assertTrue(Files.isRegularFile(guard), "启动期 DEFAULT 哨兵应存在:" + guard);
String text = raw(guard);
assertTrue(text.contains("COMPANY_DEFAULT_STILL_PRESENT"), "哨兵标记串必须保持 ASCII 原样(巡检按它 grep)");
assertTrue(text.contains("'" + TABLE + "'"),
"探针 SQL 的 IN 列表要含 " + TABLE + "(不在 IN 里就查不到这一列,哨兵等于没探)");
assertTrue(text.contains("\"" + TABLE + "\""),
"WATCHED_TABLES 清单要含 " + TABLE + "(查到了却不在清单里,就没人去喊那条签名)");
}
/** 破坏点:盘点文档没跟着改 ⇒ 下一个人按"取号起点"取号就撞号,或按"最新版本"漏掉本文件。 */
@Test
void inventoryDocTracksTheShopKeyFile() throws IOException {
Path doc = ROOT.resolve("docs/migration-inventory.md");
String text = raw(doc);
assertTrue(text.contains(migration().getFileName().toString()),
"盘点文档应逐字保留本迁移文件名:" + migration().getFileName());
assertTrue(text.contains("V147__product_category_company_scope.sql"),
"盘点文档应同时保留更早的文件名:只钉最新一条会重演「推进概览时把旧条目挤掉」那一次回归");
}
/** 自检:本用例集扫的是真文件,且 normalize 后仍能命中关键串(0 命中的断言是恒绿的)。 */
@Test
void scannedSignaturesAreActuallyPresent() throws IOException {
String sql = statements();
assertTrue(sql.length() > 120, "剥注释后的 SQL 太短,说明预处理把内容吃掉了:" + sql.length());
assertTrue(count(sql, "ALTER TABLE") >= 1 && count(sql, "information_schema") > 0,
"关键签名 0 命中=预处理或文件路径坏了,本类的断言全部不可信");
String rollbackExecutable = normalize(stripComments(raw(ROOT.resolve("docs/rollback-V150-shop-key-company.sql"))));
assertTrue(raw(ROOT.resolve("docs/rollback-V150-shop-key-company.sql")).contains("--"),
"回滚补丁若一条注释都没有,上面那条「可执行段为空」就成了恒真断言");
assertTrue(rollbackExecutable.isEmpty(), "回滚补丁的可执行段应当确实为空");
}
private static int count(String haystack, String needle) {
int n = 0, i = haystack.indexOf(needle);
while (i >= 0) {
n++;
i = haystack.indexOf(needle, i + needle.length());
}
return n;
}
}