diff --git a/src/backend/src/seed.rs b/src/backend/src/seed.rs index 4ea67f2..19d7f2f 100644 --- a/src/backend/src/seed.rs +++ b/src/backend/src/seed.rs @@ -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)", ¶ms, ) .await?; diff --git a/src/backend/tests/seed_it.rs b/src/backend/tests/seed_it.rs index 811c3f7..be2cf7b 100644 --- a/src/backend/tests/seed_it.rs +++ b/src/backend/tests/seed_it.rs @@ -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 上" + ); +}