diff --git a/src/backend/src/seed.rs b/src/backend/src/seed.rs index aecdc29..4ea67f2 100644 --- a/src/backend/src/seed.rs +++ b/src/backend/src/seed.rs @@ -1,3 +1,480 @@ -//! seed —— 两段式种子(ensure_base + first_seed)。 +//! seed —— 两段式种子(`ensure_base` 幂等 + `first_seed` 首启)。 //! -//! TODO:占位模块,后续任务填充实现。 +//! 契约:`docs/contract.md` §8.4(内置菜单)/ §8.5(内置角色)/ §8.6(种子行为)。 +//! +//! 两段式: +//! - [`ensure_base`]:**每次启动都跑**,幂等 —— 只补缺项,**绝不覆盖已改值**; +//! - [`first_seed`]:**仅当 `base_user` 行数为 0 时**跑一次 —— 建 admin 用户 + 角色关联。 +//! +//! 🔴 **不复活软删行**:内置角色 / 内置菜单的存在性判定**不按 `f_delete_mark` 过滤** +//! (契约 §8.6 明确要求)⇒ 用户手动软删的行不会被种子「复活」。 +//! 🔴 **授权行同理**:`base_authorize` 的「已授权」判定也不按 `f_delete_mark` 过滤 +//! ⇒ 软删的授权行也算「已授权」⇒ 不补。 +//! +//! 🔴 **官方 DDL 陷阱**:`base_role_relation` **没有** `f_user_id` 列 —— 用户 id 存在 +//! `f_object_id`(配 `f_object_type='user'`);`base_user_relation` 才有 `f_user_id`。 +//! 写错列 ⇒ 授权永远不生效且**静默**。 +//! 🔴 7 张 `base_*` 表的主键是复合键 `(f_id, f_tenant_id)`,`f_tenant_id` 是 +//! `NOT NULL DEFAULT '0'` ⇒ **INSERT 必须显式写 `f_tenant_id='0'`**。 + +use crate::cipher::md5_hex; +use crate::db::{pglite, pglite::ToSql, Db}; +use crate::ids::new_uuid; + +/// 内置 admin 账号名(同时用作种子的 `f_creator_user_id`)。 +const ADMIN_ACCOUNT: &str = "admin"; + +/// 内置 admin 角色的 `f_en_code`(内置角色清单里 `admin` 的编码)。 +const ADMIN_ROLE_EN_CODE: &str = "admin"; + +/// 内置 admin 角色的**字面量** id(`first_seed` 的角色关联引用它)。 +const ADMIN_ROLE_ID: &str = "role_admin"; + +/// 内置角色(契约 §8.5)—— 逐字值,**不得改动**。 +const BUILTIN_ROLES: [BuiltinRole; 2] = [ + BuiltinRole { + id: "role_admin", + full_name: "管理员", + en_code: "admin", + sort_code: 1, + }, + BuiltinRole { + id: "role_user", + full_name: "使用者", + en_code: "user", + sort_code: 2, + }, +]; + +/// 内置菜单(契约 §8.4)—— 逐字值,**不得改动**。 +const BUILTIN_MENUS: [BuiltinMenu; 8] = [ + BuiltinMenu { + id: "m_sys", + full_name: "系统管理", + url_address: "system", + parent_id: "0", + menu_type: 1, + icon: Some("setting"), + sort_code: 1, + }, + BuiltinMenu { + id: "m_user", + full_name: "用户管理", + url_address: "system/User", + parent_id: "m_sys", + menu_type: 2, + icon: None, + sort_code: 2, + }, + BuiltinMenu { + id: "m_role", + full_name: "角色管理", + url_address: "system/Role", + parent_id: "m_sys", + menu_type: 2, + icon: None, + sort_code: 3, + }, + BuiltinMenu { + id: "m_org", + full_name: "机构管理", + url_address: "system/Organize", + parent_id: "m_sys", + menu_type: 2, + icon: None, + sort_code: 4, + }, + BuiltinMenu { + id: "m_menu", + full_name: "菜单管理", + url_address: "system/Module", + parent_id: "m_sys", + menu_type: 2, + icon: None, + sort_code: 5, + }, + BuiltinMenu { + id: "m_demo", + full_name: "Demo 示例", + url_address: "demo-item", + parent_id: "0", + menu_type: 2, + icon: Some("app"), + sort_code: 6, + }, + BuiltinMenu { + id: "m_product", + full_name: "产品管理", + url_address: "shop/Product", + parent_id: "0", + menu_type: 2, + icon: Some("app"), + sort_code: 7, + }, + BuiltinMenu { + id: "m_book", + full_name: "图书超市", + url_address: "books/Book", + parent_id: "0", + menu_type: 2, + icon: Some("app"), + sort_code: 8, + }, +]; + +/// 内置角色的一行(契约 §8.5)。 +struct BuiltinRole { + /// 字面量主键(`role_admin` / `role_user`)。 + id: &'static str, + /// 全名(`管理员` / `使用者`)。 + full_name: &'static str, + /// 编码(`admin` / `user`)—— **存在性判定的依据**。 + en_code: &'static str, + /// 排序码。 + sort_code: i64, +} + +/// 内置菜单的一行(契约 §8.4)。 +struct BuiltinMenu { + /// 字面量主键(`m_sys` / `m_user` / …)。 + id: &'static str, + /// 全名。 + full_name: &'static str, + /// 前端 Route path(去前导斜杠)—— **存在性判定的依据**。 + url_address: &'static str, + /// 父菜单 id(`0` = 根)。 + parent_id: &'static str, + /// 1 = 目录 / 2 = 页面 —— 🔴 官方 DDL 里 `f_type` 是 **INTEGER**,不是字符串。 + menu_type: i32, + /// 图标 —— 🔴 `None` ⇒ 写 **NULL**(不是空串)。 + icon: Option<&'static str>, + /// 排序码。 + sort_code: i64, +} + +/// 两段式种子的第一段:**补内置角色 / 内置菜单 / admin 授权**(幂等,每次启动都跑)。 +/// +/// 契约 §8.6。行为要点: +/// 1. 内置角色按 `f_en_code` 判存在、内置菜单按 `f_url_address` 判存在 +/// —— 🔴 **都不按 `f_delete_mark` 过滤** ⇒ 软删行不被复活。 +/// 2. admin 授权按 `(f_object_type='role', f_object_id, f_item_type='module', f_item_id)` +/// 判存在 —— 🔴 同样**不按 `f_delete_mark` 过滤**。 +/// 3. **只补缺项,绝不覆盖已改值**(人工改名 / 调序 / 软删都会被保留)。 +pub async fn ensure_base(db: &Db) -> Result<(), pglite::Error> { + let now = now_str(); + ensure_builtin_roles(db, &now).await?; + ensure_builtin_menus(db, &now).await?; + ensure_admin_authorizations(db, &now).await?; + Ok(()) +} + +/// 两段式种子的第二段:**首次启动**建 admin 用户 + 角色关联。 +/// +/// 契约 §8.6:**仅当 `base_user` 行数为 0 时**才跑(否则直接返回,什么都不做)。 +pub async fn first_seed(db: &Db) -> Result<(), pglite::Error> { + let count = db.scalar_text("SELECT count(*) FROM base_user").await?; + // 🔴 `count(*)` 恒有一行;万一查不到(None)也**不**种(宁可少种也不要重复 admin)。 + if count.as_deref() != Some("0") { + return Ok(()); + } + + let now = now_str(); + seed_admin_user(db, &now).await?; + seed_admin_role_relation(db, &now).await?; + Ok(()) +} + +// ---- 内置角色 ---- + +/// 补内置角色(按 `f_en_code` 判存在;含软删行 ⇒ 不复活、不覆盖)。 +async fn ensure_builtin_roles(db: &Db, now: &str) -> Result<(), pglite::Error> { + for role in BUILTIN_ROLES { + let en_code = role.en_code.to_string(); + // 🔴 **不按 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], + ) + .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(); + let enabled_mark = "1".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); 10] = [ + &id, + &full_name, + &en_code, + &role_type, + &sort_code, + &enabled_mark, + &delete_mark, + &tenant_id, + &creator, + &now, + ]; + 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, f_creator_user_id, f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::bigint, \ + $6::text::integer, $7::text::integer, $8::text, $9::text, \ + $10::text::timestamp)", + ¶ms, + ) + .await?; + } + Ok(()) +} + +// ---- 内置菜单 ---- + +/// 补内置菜单(按 `f_url_address` 判存在;含软删行 ⇒ 不复活、不覆盖)。 +async fn ensure_builtin_menus(db: &Db, now: &str) -> Result<(), pglite::Error> { + for menu in BUILTIN_MENUS { + let url_address = menu.url_address.to_string(); + // 🔴 **不按 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], + ) + .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(); + // 🔴 图标为 `None` ⇒ 写 **NULL**(契约 §8.4 的 `—`,不是空串)。 + let icon = menu.icon.map(str::to_string); + let sort_code = menu.sort_code.to_string(); + let enabled_mark = "1".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); 12] = [ + &id, + &full_name, + &url_address, + &parent_id, + &menu_type, + &icon, + &sort_code, + &enabled_mark, + &delete_mark, + &tenant_id, + &creator, + &now, + ]; + db.exec_params( + "INSERT INTO base_module \ + (f_id, f_full_name, f_url_address, f_parent_id, f_type, f_icon, f_sort_code, \ + f_enabled_mark, f_delete_mark, f_tenant_id, f_creator_user_id, f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::integer, $6::text, \ + $7::text::bigint, $8::text::integer, $9::text::integer, $10::text, \ + $11::text, $12::text::timestamp)", + ¶ms, + ) + .await?; + } + Ok(()) +} + +// ---- admin 授权 ---- + +/// 补 admin 角色对内置菜单的授权(只补缺项)。 +/// +/// 契约 §8.6: +/// - admin 角色行取 `f_en_code='admin'` 的**真实**行(🔴 不按 `f_delete_mark` 过滤, +/// 可能是用户自建的行 ⇒ id 不等于 `role_admin`); +/// - 待授权的菜单 = `f_delete_mark=0` **且** `f_url_address` 命中内置清单的行; +/// - 「已授权」判定 = `base_authorize` 中 +/// `f_object_type='role' AND f_object_id= AND f_item_type='module'` +/// 的**全部行**(🔴 不按 `f_delete_mark` 过滤)。 +async fn ensure_admin_authorizations(db: &Db, now: &str) -> Result<(), pglite::Error> { + // ---- 1) 取 admin 角色的真实行 ---- + let en_code = ADMIN_ROLE_EN_CODE.to_string(); + // 🔴 用的是**查到的真实行**(可能是用户自建的行 ⇒ id 不等于 `role_admin`)。 + // `f_en_code` 没有 UNIQUE 约束(应用层保证唯一)⇒ 万一有多行,按 `f_id` 取 + // 最小的那条,保证结果**确定**(同库多次跑 ⇒ 同一个 id)。 + let admin_roles = db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_role WHERE f_en_code = $1::text \ + ORDER BY f_id LIMIT 1", + &[&en_code], + ) + .await?; + let Some(admin_role) = admin_roles.first() else { + // 没有 admin 角色 ⇒ 无从授权(`ensure_builtin_roles` 刚补过,除非被并发删了)。 + return Ok(()); + }; + let admin_role_id = admin_role["id"].as_str().unwrap_or_default().to_string(); + if admin_role_id.is_empty() { + return Ok(()); + } + + // ---- 2) 取内置菜单里「还活着」的行(f_delete_mark=0 且 url 命中清单)---- + let live_modules = db + .query_json( + "SELECT f_id AS \"id\", f_url_address AS \"urlAddress\" \ + FROM base_module WHERE f_delete_mark = 0", + ) + .await?; + let builtin_live: Vec = live_modules + .iter() + .filter(|row| { + row["urlAddress"] + .as_str() + .map(|url| BUILTIN_MENUS.iter().any(|m| m.url_address == url)) + .unwrap_or(false) + }) + .filter_map(|row| row["id"].as_str().map(str::to_string)) + .collect(); + + // ---- 3) 取「已授权」的 f_item_id 集合 ---- + // + // 🔴 **不按 f_delete_mark 过滤** ⇒ 软删的授权行也算「已授权」⇒ 不补。 + let granted = db + .query_json_params( + "SELECT f_item_id AS \"itemId\" FROM base_authorize \ + WHERE f_object_type = 'role' AND f_object_id = $1::text \ + AND f_item_type = 'module'", + &[&admin_role_id], + ) + .await?; + let granted: Vec = granted + .iter() + .filter_map(|row| row["itemId"].as_str().map(str::to_string)) + .collect(); + + // ---- 4) 缺项 ⇒ 补一条授权 ---- + for menu_id in builtin_live { + if granted.iter().any(|g| g == &menu_id) { + continue; + } + let auth_id = new_uuid(); + let sort_code = "0".to_string(); + let delete_mark = "0".to_string(); + let creator = ADMIN_ACCOUNT.to_string(); + let now = now.to_string(); + let params: [&(dyn ToSql + Sync); 7] = [ + &auth_id, + &admin_role_id, + &menu_id, + &sort_code, + &creator, + &now, + &delete_mark, + ]; + db.exec_params( + "INSERT INTO base_authorize \ + (f_id, f_object_type, f_object_id, f_item_type, f_item_id, f_sort_code, \ + f_creator_user_id, f_creator_time, f_delete_mark, f_tenant_id) \ + VALUES ($1::text, 'role', $2::text, 'module', $3::text, $4::text::bigint, \ + $5::text, $6::text::timestamp, $7::text::integer, '0')", + ¶ms, + ) + .await?; + } + Ok(()) +} + +// ---- 首启:admin 用户 + 角色关联 ---- + +/// 建 admin 用户(`f_password` = `md5_hex("123456")`)。 +async fn seed_admin_user(db: &Db, now: &str) -> Result<(), pglite::Error> { + let id = new_uuid(); + let account = ADMIN_ACCOUNT.to_string(); + let real_name = "管理员".to_string(); + let password = md5_hex("123456"); + let is_administrator = "1".to_string(); + let organize_id = "0".to_string(); + let creator = ADMIN_ACCOUNT.to_string(); + let now = now.to_string(); + let enabled_mark = "1".to_string(); + let delete_mark = "0".to_string(); + let tenant_id = "0".to_string(); + let params: [&(dyn ToSql + Sync); 11] = [ + &id, + &account, + &real_name, + &password, + &is_administrator, + &organize_id, + &creator, + &now, + &enabled_mark, + &delete_mark, + &tenant_id, + ]; + db.exec_params( + "INSERT INTO base_user \ + (f_id, f_account, f_real_name, f_password, f_is_administrator, f_organize_id, \ + f_creator_user_id, f_creator_time, f_enabled_mark, f_delete_mark, f_tenant_id) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::integer, $6::text, \ + $7::text, $8::text::timestamp, $9::text::integer, $10::text::integer, \ + $11::text)", + ¶ms, + ) + .await?; + Ok(()) +} + +/// 建 admin 的角色关联(`base_role_relation`)。 +/// +/// 🔴 官方 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> { + let id = new_uuid(); + let role_id = ADMIN_ROLE_ID.to_string(); + let object_type = "user".to_string(); + let object_id = ADMIN_ACCOUNT.to_string(); + 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] = [ + &id, + &role_id, + &object_type, + &object_id, + &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) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::bigint, \ + $6::text::integer, $7::text, $8::text, $9::text::timestamp)", + ¶ms, + ) + .await?; + Ok(()) +} + +/// 当前 UTC 朴素时间 ⇒ `YYYY-MM-DD HH:MM:SS`(PG `TIMESTAMP(0)` 是秒精度、无时区)。 +fn now_str() -> String { + chrono::Utc::now() + .naive_utc() + .format("%Y-%m-%d %H:%M:%S") + .to_string() +} diff --git a/src/backend/tests/seed_it.rs b/src/backend/tests/seed_it.rs new file mode 100644 index 0000000..811c3f7 --- /dev/null +++ b/src/backend/tests/seed_it.rs @@ -0,0 +1,320 @@ +//! seed 集成测试 —— 两段式种子(`ensure_base` 幂等 + `first_seed` 首启)。 +//! +//! 🔴 pglite-rs 0.2.7 是**进程级全局标志**:一个进程一辈子只能开一个实例 +//! (第二次 `open()` ⇒ `Error::AlreadyOpen`)⇒ 全文件**共用一个临时库** +//! (`OnceCell` 起一次),不每个测试函数各开一个。 +//! +//! 🔴 **测试之间必须串行**:Rust 的 test harness 把同一个 `tests/*.rs` 里的 +//! `#[tokio::test]` **并发**跑(不同线程)⇒ 共用一个库时它们会互相踩数据。 +//! ⇒ 用一把进程级 `tokio::sync::Mutex` 把每个测试**整体**串起来。 +//! 🔴 **不依赖测试执行顺序**:每个测试自己先清库 + 重新种子,造出确定的前置条件。 + +use tds_lite_rs::cipher::md5_hex; +use tds_lite_rs::db::Db; +use tds_lite_rs::seed::{ensure_base, first_seed}; +use tokio::sync::{Mutex, OnceCell}; + +/// 全文件共享的临时库。 +static DB: OnceCell = OnceCell::const_new(); + +/// 把同文件的测试**整体**串行化(共用一个库 ⇒ 必须串行)。 +static LOCK: Mutex<()> = Mutex::const_new(()); + +async fn db() -> &'static Db { + DB.get_or_init(|| async { + let db = Db::open_temp() + .await + .expect("打开 pglite 临时库失败"); + db.ensure_schema().await.expect("ensure_schema 失败"); + 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", +]; + +/// 内置菜单的 url(契约 §8.4)—— 断言用。 +const BUILTIN_MENU_URLS: [&str; 8] = [ + "system", + "system/User", + "system/Role", + "system/Organize", + "system/Module", + "demo-item", + "shop/Product", + "books/Book", +]; + +/// 清空种子相关的表 + 重新走一遍「首启 + 补内置」⇒ 确定的前置条件。 +/// +/// 🔴 不依赖「这个测试恰好第一个跑」—— test harness 的执行顺序**不保证**。 +async fn reset_and_seed(db: &Db) { + db.exec( + "DELETE FROM base_authorize; \ + DELETE FROM base_role_relation; \ + DELETE FROM base_user; \ + DELETE FROM base_module; \ + DELETE FROM base_role;", + ) + .await + .expect("清库失败"); + first_seed(db).await.expect("first_seed 失败"); + ensure_base(db).await.expect("ensure_base 失败"); +} + +/// 计数(`scalar_text` ⇒ 十进制文本)。 +async fn count(db: &Db, sql: &str) -> i64 { + let raw = db.scalar_text(sql).await.expect("count 失败"); + raw.expect("count(*) 恒有一行") + .parse::() + .expect("count(*) 必须是十进制文本") +} + +/// 五张种子相关表的行数快照。 +#[derive(Debug, PartialEq, Eq)] +struct Counts { + user: i64, + role: i64, + module: i64, + authorize: i64, + role_relation: i64, +} + +async fn counts(db: &Db) -> Counts { + Counts { + user: count(db, "SELECT count(*) FROM base_user").await, + role: count(db, "SELECT count(*) FROM base_role").await, + module: count(db, "SELECT count(*) FROM base_module").await, + authorize: count(db, "SELECT count(*) FROM base_authorize").await, + role_relation: count(db, "SELECT count(*) FROM base_role_relation").await, + } +} + +/// 空库启动 ⇒ admin/123456 + 2 角色 + 8 菜单 + admin 对 8 个内置菜单的授权。 +#[tokio::test] +async fn empty_db_seeds_admin_roles_menus_and_authorizations() { + let db = db().await; + let _guard = LOCK.lock().await; + + reset_and_seed(db).await; + + // ---- base_user:1 行 admin ---- + let users = db + .query_json( + "SELECT f_id AS \"id\", f_account AS \"account\", f_real_name AS \"realName\", \ + f_password AS \"password\", f_is_administrator AS \"isAdministrator\", \ + f_organize_id AS \"organizeId\", f_enabled_mark AS \"enabledMark\", \ + f_delete_mark AS \"deleteMark\", f_tenant_id AS \"tenantId\" \ + FROM base_user", + ) + .await + .expect("读 base_user 失败"); + 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"], "管理员", "姓名必须是 管理员"); + assert_eq!( + u["password"], + md5_hex("123456"), + "口令必须是 md5_hex(\"123456\")" + ); + assert_eq!(u["isAdministrator"].as_i64(), Some(1), "必须是管理员"); + assert_eq!(u["organizeId"], "0"); + assert_eq!(u["enabledMark"].as_i64(), Some(1)); + assert_eq!(u["deleteMark"].as_i64(), Some(0)); + assert_eq!(u["tenantId"], "0"); + assert_eq!( + u["id"].as_str().map(str::len), + Some(36), + "用户主键应是 36 位 UUID v4" + ); + + // ---- base_role:admin / user 两行 ---- + let roles = db + .query_json( + "SELECT f_id AS \"id\", f_en_code AS \"enCode\", f_full_name AS \"fullName\", \ + f_type AS \"type\", f_sort_code AS \"sortCode\", \ + f_enabled_mark AS \"enabledMark\", f_delete_mark AS \"deleteMark\", \ + f_tenant_id AS \"tenantId\" FROM base_role ORDER BY f_sort_code", + ) + .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)); + + // ---- base_module:8 行内置菜单 ---- + 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\" \ + 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!(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 + .query_json( + "SELECT f_object_type AS \"objectType\", f_object_id AS \"objectId\", \ + f_item_type AS \"itemType\", f_item_id AS \"itemId\", \ + f_sort_code AS \"sortCode\", f_delete_mark AS \"deleteMark\", \ + f_tenant_id AS \"tenantId\" FROM base_authorize", + ) + .await + .expect("读 base_authorize 失败"); + 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 角色"); + assert_eq!(a["itemType"], "module"); + 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(); + expected.sort_unstable(); + assert_eq!(item_ids, expected, "授权的菜单集合必须与内置清单逐条相等"); + + // ---- base_role_relation:admin → role_admin ---- + // + // 🔴 官方 DDL 陷阱:`base_role_relation` 没有 `f_user_id` —— 用户标识在 `f_object_id`。 + let rels = db + .query_json( + "SELECT f_role_id AS \"roleId\", f_object_type AS \"objectType\", \ + f_object_id AS \"objectId\", f_sort_code AS \"sortCode\", \ + f_delete_mark AS \"deleteMark\", f_tenant_id AS \"tenantId\" \ + FROM base_role_relation", + ) + .await + .expect("读 base_role_relation 失败"); + 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"); + assert_eq!(rels[0]["sortCode"].as_i64(), Some(0)); + assert_eq!(rels[0]["deleteMark"].as_i64(), Some(0)); + assert_eq!(rels[0]["tenantId"], "0"); +} + +/// 再启动一次 ⇒ 库内容**完全不变**(`first_seed` 此时不跑,`base_user` 仍 1 行)。 +#[tokio::test] +async fn rerunning_seed_changes_nothing() { + let db = db().await; + let _guard = LOCK.lock().await; + + reset_and_seed(db).await; + 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(db).await.expect("二次 first_seed 失败"); + + let after = counts(db).await; + assert_eq!(before, after, "二次种子后各表行数必须完全不变"); + assert_eq!(after.user, 1, "base_user 仍是 1 行(不是 2 行)"); + assert_eq!(after.role, 2); + assert_eq!(after.module, 8); + assert_eq!(after.authorize, 8); + assert_eq!(after.role_relation, 1); +} + +/// 软删一行内置菜单 ⇒ 再跑 `ensure_base` ⇒ **不复活**、行数不变。 +#[tokio::test] +async fn soft_deleted_builtin_menu_is_not_revived() { + let db = db().await; + let _guard = LOCK.lock().await; + + reset_and_seed(db).await; + db.exec("UPDATE base_module SET f_delete_mark = 1 WHERE f_id = 'm_user'") + .await + .expect("软删 m_user 失败"); + let before = counts(db).await; + + ensure_base(db).await.expect("ensure_base 失败"); + + let after = counts(db).await; + assert_eq!( + before.module, after.module, + "软删的行不得被复活(行数必须不变)" + ); + assert_eq!(after.module, 8, "base_module 仍是 8 行"); + + let rows = db + .query_json( + "SELECT f_id AS \"id\", f_delete_mark AS \"deleteMark\" FROM base_module \ + WHERE f_id = 'm_user'", + ) + .await + .expect("读 m_user 失败"); + assert_eq!(rows.len(), 1, "m_user 行仍在(没被删)"); + assert_eq!( + rows[0]["deleteMark"].as_i64(), + Some(1), + "m_user 必须仍是软删状态(不被复活)" + ); +} + +/// 改内置角色的全名 ⇒ 再跑 `ensure_base` ⇒ **不被覆盖**。 +#[tokio::test] +async fn renamed_builtin_role_is_not_overwritten() { + let db = db().await; + let _guard = LOCK.lock().await; + + reset_and_seed(db).await; + db.exec("UPDATE base_role SET f_full_name = '超级管理员' WHERE f_en_code = 'admin'") + .await + .expect("改角色名失败"); + + ensure_base(db).await.expect("ensure_base 失败"); + + let rows = db + .query_json( + "SELECT f_full_name AS \"fullName\" FROM base_role WHERE f_en_code = 'admin'", + ) + .await + .expect("读角色失败"); + assert_eq!(rows.len(), 1); + assert_eq!( + rows[0]["fullName"], "超级管理员", + "人工改过的名字不得被种子覆盖" + ); +}