feat: 两段式种子(ensure_base 幂等 + first_seed 首启)

Co-Authored-By: Claude Code <[email protected]>
This commit is contained in:
adminandClaude Code committed 2026-10-25 21:25:01 +08:00
1 parent aa45da8e29
commit cbc8897028
2 files changed
+799 -2

No files matched your search

+479 -2
View File
@@ -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)",
&params,
)
.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)",
&params,
)
.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=<adminRoleId> 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<String> = 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<String> = 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')",
&params,
)
.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)",
&params,
)
.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)",
&params,
)
.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()
}
+320
View File
@@ -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<Db> = 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::<i64>()
.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"], "超级管理员",
"人工改过的名字不得被种子覆盖"
);
}