fix(seed): 存在性判定对齐固定 id + 补齐 §8.4/§8.5 断言

Co-Authored-By: Claude Code <[email protected]>
This commit is contained in:
adminandClaude Code committed 2026-10-25 21:42:25 +08:00
1 parent 15469ea635
commit 1fc85a596b
2 files changed
+278 -72

No files matched your search

+37 -19
View File
@@ -11,6 +11,13 @@
//! 🔴 **授权行同理**:`base_authorize` 的「已授权」判定也不按 `f_delete_mark` 过滤
//! ⇒ 软删的授权行也算「已授权」⇒ 不补。
//!
//! 🔴 **存在性判定必须与固定字面量 id 对齐**:内置角色按
//! 「`f_en_code` 命中清单 **或** `f_id` = 固定字面量」判,内置菜单按
//! 「`f_url_address` 命中清单 **或** `f_id` = 固定字面量」判 ——
//! INSERT 用的是**固定字面量 id**(`role_admin` / `m_user` …),若只按
//! en_code / url 判,用户在 UI 改过内置项的这两个字段后就会「查不到 ⇒ 撞复合主键」
//! ⇒ 种子失败 ⇒ 进程 exit 1 ⇒ 此后每次启动都失败(且服务起不来 ⇒ 用户也没法用 UI 改回去)。
//!
//! 🔴 **官方 DDL 陷阱**:`base_role_relation` **没有** `f_user_id` 列 —— 用户 id 存在
//! `f_object_id`(配 `f_object_type='user'`);`base_user_relation` 才有 `f_user_id`。
//! 写错列 ⇒ 授权永远不生效且**静默**。
@@ -180,28 +187,33 @@ pub async fn first_seed(db: &Db) -> Result<(), pglite::Error> {
let now = now_str();
seed_admin_user(db, &now).await?;
seed_admin_role_relation(db, &now).await?;
seed_admin_role_relation(db).await?;
Ok(())
}
// ---- 内置角色 ----
/// 补内置角色(按 `f_en_code` 判存在;含软删行 ⇒ 不复活、不覆盖)。
/// 补内置角色(按 `f_en_code` **或** `f_id` 判存在;含软删行 ⇒ 不复活、不覆盖)。
async fn ensure_builtin_roles(db: &Db, now: &str) -> Result<(), pglite::Error> {
for role in BUILTIN_ROLES {
let id = role.id.to_string();
let en_code = role.en_code.to_string();
// 🔴 **不按 f_delete_mark 过滤** —— 软删行也算「已存在」。
// 🔴 存在性判定 = 「`f_en_code` 命中 **或** `f_id` = 固定字面量」。
// 只按 en_code 判会出事:用户把内置角色的 `f_en_code` 改掉后,
// 下次启动会「查不到 ⇒ INSERT 固定 id」⇒ **撞复合主键** ⇒ 种子失败 ⇒
// 进程 exit 1 ⇒ 此后每次启动都失败(服务起不来 ⇒ 用户也没法用 UI 改回去)。
// 🔴 **不按 f_delete_mark 过滤** —— 软删行也算「已存在」。
let existing = db
.query_json_params(
"SELECT f_id AS \"id\" FROM base_role WHERE f_en_code = $1::text LIMIT 1",
&[&en_code],
"SELECT f_id AS \"id\" FROM base_role \
WHERE f_en_code = $1::text OR f_id = $2::text LIMIT 1",
&[&en_code, &id],
)
.await?;
if !existing.is_empty() {
continue;
}
let id = role.id.to_string();
let full_name = role.full_name.to_string();
let role_type = "user".to_string();
let sort_code = role.sort_code.to_string();
@@ -238,22 +250,27 @@ async fn ensure_builtin_roles(db: &Db, now: &str) -> Result<(), pglite::Error> {
// ---- 内置菜单 ----
/// 补内置菜单(按 `f_url_address` 判存在;含软删行 ⇒ 不复活、不覆盖)。
/// 补内置菜单(按 `f_url_address` **或** `f_id` 判存在;含软删行 ⇒ 不复活、不覆盖)。
async fn ensure_builtin_menus(db: &Db, now: &str) -> Result<(), pglite::Error> {
for menu in BUILTIN_MENUS {
let id = menu.id.to_string();
let url_address = menu.url_address.to_string();
// 🔴 **不按 f_delete_mark 过滤** —— 软删行也算「已存在」(契约 §8.6 明确要求)。
// 🔴 存在性判定 = 「`f_url_address` 命中 **或** `f_id` = 固定字面量」。
// 只按 url 判会出事:用户把内置菜单的 `f_url_address` 改掉后,
// 下次启动会「查不到 ⇒ INSERT 固定 id」⇒ **撞复合主键** ⇒ 种子失败 ⇒
// 进程 exit 1 ⇒ 此后每次启动都失败(服务起不来 ⇒ 用户也没法用 UI 改回去)。
// 🔴 **不按 f_delete_mark 过滤** —— 软删行也算「已存在」(契约 §8.6 明确要求)。
let existing = db
.query_json_params(
"SELECT f_id AS \"id\" FROM base_module WHERE f_url_address = $1::text LIMIT 1",
&[&url_address],
"SELECT f_id AS \"id\" FROM base_module \
WHERE f_url_address = $1::text OR f_id = $2::text LIMIT 1",
&[&url_address, &id],
)
.await?;
if !existing.is_empty() {
continue;
}
let id = menu.id.to_string();
let full_name = menu.full_name.to_string();
let parent_id = menu.parent_id.to_string();
let menu_type = menu.menu_type.to_string();
@@ -438,7 +455,12 @@ async fn seed_admin_user(db: &Db, now: &str) -> Result<(), pglite::Error> {
/// 🔴 官方 DDL 陷阱:`base_role_relation` **没有** `f_user_id` —— 用户标识在
/// `f_object_id`(配 `f_object_type='user'`);这里逐字用**账号名** `'admin'`
/// (react 源码里就是 `'admin'`,契约 §8.6 明确要求)。
async fn seed_admin_role_relation(db: &Db, now: &str) -> Result<(), pglite::Error> {
///
/// 🔴 契约 §8.6 对这一行**逐字只列了 7 个字段**(`f_id` / `f_role_id` / `f_object_type` /
/// `f_object_id` / `f_sort_code` / `f_delete_mark` / `f_tenant_id`),**不含**
/// `f_creator_user_id` / `f_creator_time`(react 的 `roleRelRepo.save` 也不写这两列)
/// ⇒ 这里就**不写**(DDL 允许 NULL,不影响任何逻辑)。
async fn seed_admin_role_relation(db: &Db) -> Result<(), pglite::Error> {
let id = new_uuid();
let role_id = ADMIN_ROLE_ID.to_string();
let object_type = "user".to_string();
@@ -446,9 +468,7 @@ async fn seed_admin_role_relation(db: &Db, now: &str) -> Result<(), pglite::Erro
let sort_code = "0".to_string();
let delete_mark = "0".to_string();
let tenant_id = "0".to_string();
let creator = ADMIN_ACCOUNT.to_string();
let now = now.to_string();
let params: [&(dyn ToSql + Sync); 9] = [
let params: [&(dyn ToSql + Sync); 7] = [
&id,
&role_id,
&object_type,
@@ -456,15 +476,13 @@ async fn seed_admin_role_relation(db: &Db, now: &str) -> Result<(), pglite::Erro
&sort_code,
&delete_mark,
&tenant_id,
&creator,
&now,
];
db.exec_params(
"INSERT INTO base_role_relation \
(f_id, f_role_id, f_object_type, f_object_id, f_sort_code, f_delete_mark, \
f_tenant_id, f_creator_user_id, f_creator_time) \
f_tenant_id) \
VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::bigint, \
$6::text::integer, $7::text, $8::text, $9::text::timestamp)",
$6::text::integer, $7::text)",
&params,
)
.await?;
+241 -53
View File
@@ -31,27 +31,34 @@ async fn db() -> &'static Db {
.await
}
/// 内置菜单的字面量(契约 §8.4)—— 断言用。
const BUILTIN_MENU_IDS: [&str; 8] = [
"m_sys", "m_user", "m_role", "m_org", "m_menu", "m_demo", "m_product", "m_book",
/// 内置菜单的期望值(契约 §8.4)—— 逐字照抄那张表。
///
/// `(id, fullName, parentId, type, sortCode, icon)`
/// —— 🔴 `type` 是 **INTEGER**(1=目录 / 2=页面);`icon` 为 `None` ⇒ 期望 **NULL**。
const BUILTIN_MENUS: [(&str, &str, &str, i64, i64, Option<&str>); 8] = [
("m_sys", "系统管理", "0", 1, 1, Some("setting")),
("m_user", "用户管理", "m_sys", 2, 2, None),
("m_role", "角色管理", "m_sys", 2, 3, None),
("m_org", "机构管理", "m_sys", 2, 4, None),
("m_menu", "菜单管理", "m_sys", 2, 5, None),
("m_demo", "Demo 示例", "0", 2, 6, Some("app")),
("m_product", "产品管理", "0", 2, 7, Some("app")),
("m_book", "图书超市", "0", 2, 8, Some("app")),
];
/// 内置菜单的 url(契约 §8.4)—— 断言用。
const BUILTIN_MENU_URLS: [&str; 8] = [
"system",
"system/User",
"system/Role",
"system/Organize",
"system/Module",
"demo-item",
"shop/Product",
"books/Book",
/// 内置角色的期望值(契约 §8.5)—— `(id, enCode, fullName, sortCode)`。
const BUILTIN_ROLES: [(&str, &str, &str, i64); 2] = [
("role_admin", "admin", "管理员", 1),
("role_user", "user", "使用者", 2),
];
/// 清空种子相关的表 + 重新走一遍「首启 + 补内置」⇒ 确定的前置条件。
/// 用户自建的 admin 角色用的随机 UUID(**不是** `role_admin`)—— 契约 §8.6 的分支。
const CUSTOM_ADMIN_ROLE_ID: &str = "77777777-7777-4777-8777-777777777777";
/// 清空种子相关的 5 张表(造「空库」前置条件)。
///
/// 🔴 不依赖「这个测试恰好第一个跑」—— test harness 的执行顺序**不保证**。
async fn reset_and_seed(db: &Db) {
async fn clear_all(db: &Db) {
db.exec(
"DELETE FROM base_authorize; \
DELETE FROM base_role_relation; \
@@ -61,8 +68,13 @@ async fn reset_and_seed(db: &Db) {
)
.await
.expect("清库失败");
first_seed(db).await.expect("first_seed 失败");
}
/// 清库 + 走一遍**生产顺序**的种子(契约 §10:`ensure_base` → `first_seed`)。
async fn reset_and_seed(db: &Db) {
clear_all(db).await;
ensure_base(db).await.expect("ensure_base 失败");
first_seed(db).await.expect("first_seed 失败");
}
/// 计数(`scalar_text` ⇒ 十进制文本)。
@@ -112,7 +124,12 @@ async fn empty_db_seeds_admin_roles_menus_and_authorizations() {
)
.await
.expect("读 base_user 失败");
assert_eq!(users.len(), 1, "base_user 应只有 1 行(admin),实际 {:?}", users.len());
assert_eq!(
users.len(),
1,
"base_user 应只有 1 行(admin),实际 {:?}",
users.len()
);
let u = &users[0];
assert_eq!(u["account"], "admin", "账号必须是 admin");
assert_eq!(u["realName"], "管理员", "姓名必须是 管理员");
@@ -132,7 +149,7 @@ async fn empty_db_seeds_admin_roles_menus_and_authorizations() {
"用户主键应是 36 位 UUID v4"
);
// ---- base_role:admin / user 两行 ----
// ---- base_role:admin / user 两行(§8.5 的 id / enCode / fullName / sortCode 逐条钉死)----
let roles = db
.query_json(
"SELECT f_id AS \"id\", f_en_code AS \"enCode\", f_full_name AS \"fullName\", \
@@ -143,44 +160,70 @@ async fn empty_db_seeds_admin_roles_menus_and_authorizations() {
.await
.expect("读 base_role 失败");
assert_eq!(roles.len(), 2, "base_role 应有 2 行,实际 {}", roles.len());
assert_eq!(roles[0]["id"], "role_admin");
assert_eq!(roles[0]["enCode"], "admin");
assert_eq!(roles[0]["fullName"], "管理员");
assert_eq!(roles[0]["type"], "user");
assert_eq!(roles[0]["sortCode"].as_i64(), Some(1));
assert_eq!(roles[0]["enabledMark"].as_i64(), Some(1));
assert_eq!(roles[0]["deleteMark"].as_i64(), Some(0));
assert_eq!(roles[0]["tenantId"], "0");
assert_eq!(roles[1]["id"], "role_user");
assert_eq!(roles[1]["enCode"], "user");
assert_eq!(roles[1]["fullName"], "使用者");
assert_eq!(roles[1]["sortCode"].as_i64(), Some(2));
for (i, (id, en_code, full_name, sort_code)) in BUILTIN_ROLES.iter().enumerate() {
let r = &roles[i];
assert_eq!(r["id"], *id, "第 {i} 个内置角色的 id 不对");
assert_eq!(r["enCode"], *en_code, "第 {i} 个内置角色的 enCode 不对");
assert_eq!(r["fullName"], *full_name, "第 {i} 个内置角色的全名不对");
assert_eq!(r["sortCode"].as_i64(), Some(*sort_code), "第 {i} 个内置角色的 sortCode 不对");
assert_eq!(r["type"], "user", "内置角色的 f_type 必须是 'user'");
assert_eq!(r["enabledMark"].as_i64(), Some(1));
assert_eq!(r["deleteMark"].as_i64(), Some(0));
assert_eq!(r["tenantId"], "0");
}
// ---- base_module:8 行内置菜单 ----
// ---- base_module:8 行内置菜单(§8.4 逐条钉死)----
let modules = db
.query_json(
"SELECT f_id AS \"id\", f_url_address AS \"urlAddress\", \
f_full_name AS \"fullName\", f_parent_id AS \"parentId\", \
f_type AS \"type\", f_icon AS \"icon\", f_sort_code AS \"sortCode\", \
f_delete_mark AS \"deleteMark\", f_tenant_id AS \"tenantId\" \
f_enabled_mark AS \"enabledMark\", f_delete_mark AS \"deleteMark\", \
f_tenant_id AS \"tenantId\" \
FROM base_module ORDER BY f_sort_code",
)
.await
.expect("读 base_module 失败");
assert_eq!(modules.len(), 8, "base_module 应有 8 行,实际 {}", modules.len());
for (i, m) in modules.iter().enumerate() {
assert_eq!(m["id"], BUILTIN_MENU_IDS[i], "第 {i} 个菜单 id 不对");
assert_eq!(m["urlAddress"], BUILTIN_MENU_URLS[i], "第 {i} 个菜单 url 不对");
assert_eq!(
modules.len(),
8,
"base_module 应有 8 行,实际 {}",
modules.len()
);
for (i, (id, full_name, parent_id, menu_type, sort_code, icon)) in
BUILTIN_MENUS.iter().enumerate()
{
let m = &modules[i];
assert_eq!(m["id"], *id, "第 {i} 个内置菜单的 id 不对");
assert_eq!(m["fullName"], *full_name, "第 {i} 个内置菜单的全名不对");
assert_eq!(m["parentId"], *parent_id, "第 {i} 个内置菜单的 parentId 不对");
// 🔴 `f_type` 是 **INTEGER**(1=目录 / 2=页面),不是字符串。
assert_eq!(
m["type"].as_i64(),
Some(*menu_type),
"第 {i} 个内置菜单的 f_type 不对(1=目录 / 2=页面)"
);
assert_eq!(
m["sortCode"].as_i64(),
Some(*sort_code),
"第 {i} 个内置菜单的 sortCode 不对"
);
match icon {
// 🔴 `None` ⇒ 必须是 **NULL**(不是空串)。
None => assert!(
m["icon"].is_null(),
"第 {i} 个内置菜单的 icon 必须是 NULL,实际 {}",
m["icon"]
),
Some(expected) => assert_eq!(
m["icon"], *expected,
"第 {i} 个内置菜单的 icon 不对"
),
}
assert_eq!(m["enabledMark"].as_i64(), Some(1));
assert_eq!(m["deleteMark"].as_i64(), Some(0));
assert_eq!(m["tenantId"], "0");
}
// 🔴 `f_type` 是 INTEGER(1=目录 / 2=页面),不是字符串。
assert_eq!(modules[0]["type"].as_i64(), Some(1), "系统管理是目录");
assert_eq!(modules[1]["type"].as_i64(), Some(2), "用户管理是页面");
// 🔴 `m_user`/`m_role`/`m_org`/`m_menu` 的图标是 **NULL**(不是空串)。
assert!(modules[1]["icon"].is_null(), "m_user 的 icon 必须是 NULL");
assert_eq!(modules[0]["icon"], "setting");
assert_eq!(modules[1]["parentId"], "m_sys");
// ---- base_authorize:admin 角色对 8 个内置菜单都有授权 ----
let auths = db
@@ -192,7 +235,12 @@ async fn empty_db_seeds_admin_roles_menus_and_authorizations() {
)
.await
.expect("读 base_authorize 失败");
assert_eq!(auths.len(), 8, "base_authorize 应有 8 行,实际 {}", auths.len());
assert_eq!(
auths.len(),
8,
"base_authorize 应有 8 行,实际 {}",
auths.len()
);
for a in &auths {
assert_eq!(a["objectType"], "role");
assert_eq!(a["objectId"], "role_admin", "授权对象必须是 admin 角色");
@@ -200,16 +248,11 @@ async fn empty_db_seeds_admin_roles_menus_and_authorizations() {
assert_eq!(a["sortCode"].as_i64(), Some(0));
assert_eq!(a["deleteMark"].as_i64(), Some(0));
assert_eq!(a["tenantId"], "0");
let item_id = a["itemId"].as_str().unwrap_or_default();
assert!(
BUILTIN_MENU_IDS.contains(&item_id),
"授权的菜单 id 不在内置清单里: {item_id}"
);
}
// 8 个内置菜单**各一条**(不重复、不缺)。
let mut item_ids: Vec<&str> = auths.iter().map(|a| a["itemId"].as_str().unwrap()).collect();
item_ids.sort_unstable();
let mut expected: Vec<&str> = BUILTIN_MENU_IDS.to_vec();
let mut expected: Vec<&str> = BUILTIN_MENUS.iter().map(|(id, ..)| *id).collect();
expected.sort_unstable();
assert_eq!(item_ids, expected, "授权的菜单集合必须与内置清单逐条相等");
@@ -225,7 +268,12 @@ async fn empty_db_seeds_admin_roles_menus_and_authorizations() {
)
.await
.expect("读 base_role_relation 失败");
assert_eq!(rels.len(), 1, "base_role_relation 应有 1 行,实际 {}", rels.len());
assert_eq!(
rels.len(),
1,
"base_role_relation 应有 1 行,实际 {}",
rels.len()
);
assert_eq!(rels[0]["objectType"], "user");
assert_eq!(rels[0]["objectId"], "admin", "用户标识是**账号名** 'admin'");
assert_eq!(rels[0]["roleId"], "role_admin");
@@ -244,9 +292,9 @@ async fn rerunning_seed_changes_nothing() {
let before = counts(db).await;
assert_eq!(before.user, 1, "首启后 base_user 只有 1 行");
// 再跑一次(顺序刻意与首启相反:先 ensure_base 后 first_seed)。
ensure_base(db).await.expect("二次 ensure_base 失败");
// 再跑一次(顺序刻意与首启相反:先 first_seed 后 ensure_base)。
first_seed(db).await.expect("二次 first_seed 失败");
ensure_base(db).await.expect("二次 ensure_base 失败");
let after = counts(db).await;
assert_eq!(before, after, "二次种子后各表行数必须完全不变");
@@ -318,3 +366,143 @@ async fn renamed_builtin_role_is_not_overwritten() {
"人工改过的名字不得被种子覆盖"
);
}
/// 用户改过内置菜单的 `f_url_address` ⇒ 再跑 `ensure_base` ⇒ **不报错**、
/// 行数不变、**用户改的值不被覆盖**。
///
/// 🔴 回归意义:只按 url 判存在 ⇒ 「查不到 ⇒ INSERT 固定 id `m_user`」⇒ 撞复合主键
/// ⇒ 种子失败 ⇒ 进程 exit 1 ⇒ 此后每次启动都失败(且服务起不来 ⇒ 用户没法用 UI 改回去)。
#[tokio::test]
async fn user_edited_builtin_menu_url_does_not_break_seeding() {
let db = db().await;
let _guard = LOCK.lock().await;
reset_and_seed(db).await;
db.exec("UPDATE base_module SET f_url_address = 'system/UserCustom' WHERE f_id = 'm_user'")
.await
.expect("改菜单 url 失败");
let before = counts(db).await;
// 🔴 关键:这里**不能**报错(旧实现会撞主键 ⇒ Err ⇒ 种子失败 ⇒ 进程 exit 1)。
ensure_base(db).await.expect("ensure_base 失败");
let after = counts(db).await;
assert_eq!(before, after, "用户改过 url 后,各表行数必须完全不变");
assert_eq!(after.module, 8, "base_module 仍是 8 行(不得多插一行)");
let rows = db
.query_json(
"SELECT f_url_address AS \"urlAddress\" FROM base_module WHERE f_id = 'm_user'",
)
.await
.expect("读 m_user 失败");
assert_eq!(rows.len(), 1, "m_user 行仍在(没被删也没被复制)");
assert_eq!(
rows[0]["urlAddress"], "system/UserCustom",
"用户改过的 url 不得被种子覆盖"
);
}
/// 用户改过内置角色的 `f_en_code` ⇒ 再跑 `ensure_base` ⇒ **不报错**、
/// 行数不变、**用户改的值不被覆盖**。
///
/// 🔴 回归意义:只按 en_code 判存在 ⇒ 「查不到 ⇒ INSERT 固定 id `role_admin`」⇒ 撞复合主键。
#[tokio::test]
async fn user_edited_builtin_role_en_code_does_not_break_seeding() {
let db = db().await;
let _guard = LOCK.lock().await;
reset_and_seed(db).await;
db.exec("UPDATE base_role SET f_en_code = 'adminCustom' WHERE f_id = 'role_admin'")
.await
.expect("改角色 enCode 失败");
let before = counts(db).await;
// 🔴 关键:这里**不能**报错(旧实现会撞主键 ⇒ Err ⇒ 种子失败 ⇒ 进程 exit 1)。
ensure_base(db).await.expect("ensure_base 失败");
let after = counts(db).await;
assert_eq!(before, after, "用户改过 enCode 后,各表行数必须完全不变");
assert_eq!(after.role, 2, "base_role 仍是 2 行(不得多插一行)");
let rows = db
.query_json(
"SELECT f_en_code AS \"enCode\" FROM base_role WHERE f_id = 'role_admin'",
)
.await
.expect("读 role_admin 失败");
assert_eq!(rows.len(), 1, "role_admin 行仍在(没被删也没被复制)");
assert_eq!(
rows[0]["enCode"], "adminCustom",
"用户改过的 enCode 不得被种子覆盖"
);
}
/// admin 角色是**用户自建的行**(`f_id` ≠ `role_admin`)⇒ 授权行必须挂在那个随机 UUID 上,
/// 且**不得**有任何授权行挂在 `role_admin` 上(契约 §8.6)。
#[tokio::test]
async fn admin_role_created_by_user_receives_authorizations() {
let db = db().await;
let _guard = LOCK.lock().await;
clear_all(db).await;
// 用户自建的 admin 角色:`f_en_code='admin'`,但 `f_id` 是随机 UUID(**不是** `role_admin`)。
db.exec_params(
"INSERT INTO base_role (f_id, f_full_name, f_en_code, f_type, f_sort_code, \
f_enabled_mark, f_delete_mark, f_tenant_id) \
VALUES ($1::text, '我的管理员', 'admin', 'user', $2::text::bigint, \
$3::text::integer, $4::text::integer, $5::text)",
&[&CUSTOM_ADMIN_ROLE_ID, &"9", &"1", &"0", &"0"],
)
.await
.expect("插入用户自建 admin 角色失败");
ensure_base(db).await.expect("ensure_base 失败");
// ---- base_role:用户那行 + 被补上的 `role_user`;**不得**再有 `role_admin` ----
let roles = db
.query_json(
"SELECT f_id AS \"id\", f_en_code AS \"enCode\" FROM base_role ORDER BY f_id",
)
.await
.expect("读 base_role 失败");
assert_eq!(roles.len(), 2, "base_role 应是「用户自建 admin + role_user」两行");
assert!(
roles.iter().any(|r| r["id"] == CUSTOM_ADMIN_ROLE_ID),
"用户自建的 admin 角色必须还在"
);
assert!(
!roles.iter().any(|r| r["id"] == "role_admin"),
"en_code='admin' 已被占用 ⇒ 不得再插入 role_admin"
);
assert!(
roles.iter().any(|r| r["id"] == "role_user"),
"缺失的 role_user 应被补上"
);
// ---- 授权行必须挂在那个随机 UUID 上 ----
let auths = db
.query_json(
"SELECT f_object_id AS \"objectId\", f_item_type AS \"itemType\", \
f_item_id AS \"itemId\" FROM base_authorize",
)
.await
.expect("读 base_authorize 失败");
assert_eq!(
auths.len(),
8,
"admin 角色应对 8 个内置菜单都有授权,实际 {}",
auths.len()
);
for a in &auths {
assert_eq!(
a["objectId"], CUSTOM_ADMIN_ROLE_ID,
"授权必须挂在**真实**的 admin 角色行上"
);
assert_eq!(a["itemType"], "module");
}
assert!(
!auths.iter().any(|a| a["objectId"] == "role_admin"),
"不得有任何授权行挂在 role_admin 上"
);
}