test(permission): 钉住关系表不过滤 delete_mark / f_item_type='module' / 管理员 SQL 前短路

评审 R=1(Approved,Critical 0 / Important 0 / Minor 5)⇒ 实现逻辑零改动,
只补 3 条测试钉子:

- soft_deleted_role_relation_still_counts /
  soft_deleted_user_relation_still_counts:钉住「只有 base_authorize 过滤
  f_delete_mark=0,两张关系表不过滤」(契约 §8.1 / brief S14)
- non_module_item_type_does_not_grant:钉住 base_authorize.f_item_type='module'
- db_error_denies_instead_of_allowing(扩展):base_module 被 DROP 的那段时间里
  管理员仍放行 ⇒ 钉住「管理员在任何 SQL 之前短路」

permission.rs 仅给 MAX_TREE_DEPTH 补注释(防御性上限,react 无此概念)。

Co-Authored-By: Claude Code <[email protected]>
This commit is contained in:
adminandClaude Code committed 2026-10-25 22:10:06 +08:00
1 parent 6a0cadb143
commit b39168205c
2 files changed
+143 -12

No files matched your search

+4
View File
@@ -67,6 +67,10 @@ struct MenuRow {
}
/// 菜单树的最大层数(防御 `f_parent_id` 被改成人为环时的无限递归)。
///
/// 🔴 **这是防御性上限,react 无此概念**(react 的 `toTree` 没有层数概念)——
/// 契约 §8.3 对层数也无规定。截断只在「菜单嵌套 > 32 层」时生效,
/// 现实中不可达;不封顶则极深的链会让递归爆栈 ⇒ 整个进程死掉。
const MAX_TREE_DEPTH: usize = 32;
/// 四源合并(契约 §8.1)—— 用户可见的菜单 id 集合。
+139 -12
View File
@@ -47,22 +47,30 @@ const M_BOOK: &str = "m_book";
const EXPECTED_ADMIN_TREE: &str =
"系统管理:用户管理,角色管理,机构管理,菜单管理|Demo 示例:|产品管理:|图书超市:";
/// 造一条授权行(`base_authorize`)。
/// 造一条授权行(`base_authorize`),`f_item_type` 可指定。
///
/// 🔴 **只有 `base_authorize` 过滤 `f_delete_mark=0`**(react 的 `addAuthorized` 只在
/// 这一张表上加了 `deleteMark: 0`)⇒ `base_role_relation` / `base_user_relation`
/// **不过滤**软删(照抄 react,别自作主张加过滤)。
async fn grant(db: &Db, object_type: &str, object_id: &str, item_id: &str) {
async fn grant_with_item_type(
db: &Db,
object_type: &str,
object_id: &str,
item_id: &str,
item_type: &str,
) {
let id = new_uuid();
let object_type = object_type.to_string();
let object_id = object_id.to_string();
let item_type = item_type.to_string();
let item_id = item_id.to_string();
let sort_code = "0".to_string();
let delete_mark = "0".to_string();
let params: [&(dyn tds_lite_rs::db::pglite::ToSql + Sync); 6] = [
let params: [&(dyn tds_lite_rs::db::pglite::ToSql + Sync); 7] = [
&id,
&object_type,
&object_id,
&item_type,
&item_id,
&sort_code,
&delete_mark,
@@ -71,25 +79,30 @@ async fn grant(db: &Db, object_type: &str, object_id: &str, item_id: &str) {
"INSERT INTO base_authorize \
(f_id, f_object_type, f_object_id, f_item_type, f_item_id, f_sort_code, \
f_delete_mark, f_tenant_id) \
VALUES ($1::text, $2::text, $3::text, 'module', $4::text, $5::text::bigint, \
$6::text::integer, '0')",
VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::bigint, \
$7::text::integer, '0')",
&params,
)
.await
.expect("插入授权行失败");
}
/// 造一条用户↔角色关系行(`base_role_relation`)。
/// 造一条 `f_item_type='module'` 的授权行。
async fn grant(db: &Db, object_type: &str, object_id: &str, item_id: &str) {
grant_with_item_type(db, object_type, object_id, item_id, "module").await;
}
/// 造一条用户↔角色关系行(`base_role_relation`),`f_delete_mark` 可指定。
///
/// 🔴 官方 DDL 陷阱:`base_role_relation` **没有** `f_user_id` —— 用户标识在 `f_object_id`
/// (配 `f_object_type='user'`)。写错列 ⇒ 授权永远不生效且**静默**。
async fn link_role(db: &Db, user_id: &str, role_id: &str) {
async fn link_role_with_delete_mark(db: &Db, user_id: &str, role_id: &str, delete_mark: &str) {
let id = new_uuid();
let user_id = user_id.to_string();
let role_id = role_id.to_string();
let object_type = "user".to_string();
let sort_code = "0".to_string();
let delete_mark = "0".to_string();
let delete_mark = delete_mark.to_string();
let params: [&(dyn tds_lite_rs::db::pglite::ToSql + Sync); 6] = [
&id,
&role_id,
@@ -109,16 +122,27 @@ async fn link_role(db: &Db, user_id: &str, role_id: &str) {
.expect("插入用户↔角色关系失败");
}
/// 造一条用户↔组织/岗位关系行(`base_user_relation`)。
/// 造一条用户↔角色关系行(未软删)。
async fn link_role(db: &Db, user_id: &str, role_id: &str) {
link_role_with_delete_mark(db, user_id, role_id, "0").await;
}
/// 造一条用户↔组织/岗位关系行(`base_user_relation`),`f_delete_mark` 可指定。
///
/// 🔴 官方 DDL 陷阱:`base_user_relation` **才有** `f_user_id`。
async fn link_user_relation(db: &Db, user_id: &str, object_type: &str, object_id: &str) {
async fn link_user_relation_with_delete_mark(
db: &Db,
user_id: &str,
object_type: &str,
object_id: &str,
delete_mark: &str,
) {
let id = new_uuid();
let user_id = user_id.to_string();
let object_type = object_type.to_string();
let object_id = object_id.to_string();
let sort_code = "0".to_string();
let delete_mark = "0".to_string();
let delete_mark = delete_mark.to_string();
let params: [&(dyn tds_lite_rs::db::pglite::ToSql + Sync); 6] = [
&id,
&user_id,
@@ -138,6 +162,11 @@ async fn link_user_relation(db: &Db, user_id: &str, object_type: &str, object_id
.expect("插入用户↔组织/岗位关系失败");
}
/// 造一条用户↔组织/岗位关系行(未软删)。
async fn link_user_relation(db: &Db, user_id: &str, object_type: &str, object_id: &str) {
link_user_relation_with_delete_mark(db, user_id, object_type, object_id, "0").await;
}
/// 删掉引用给定 id 的所有授权 / 关系行(造「无任何授权」前置条件)。
///
/// 🔴 不依赖测试执行顺序:每个测试自己先清干净。
@@ -286,6 +315,93 @@ async fn four_sources_are_unioned() {
);
}
/// 🔴 钉住「**关系表不过滤 `f_delete_mark`**」(契约 §8.1 / brief S14)。
///
/// 只有 `base_authorize` 过滤 `f_delete_mark = 0`(react 的 `addAuthorized` 只在
/// 这一张表上加了 `deleteMark: 0`);`base_role_relation` / `base_user_relation`
/// **不过滤**软删 ⇒ 一条**软删**的关系行,其角色 / 组织 / 岗位的授权**仍然生效**。
///
/// 回归意义:若有人给 `query_user_role_ids` / `query_user_relation_ids` 加上
/// `AND f_delete_mark = 0`,这个测试会挂 ⇒ 契约被静默改掉时有人发现。
#[tokio::test]
async fn soft_deleted_role_relation_still_counts() {
let db = db().await;
let _guard = LOCK.lock().await;
ensure_base(db).await.expect("ensure_base 失败");
let uid = "perm_it_softrel_role_user";
let rid = new_uuid();
purge(db, uid).await;
purge(db, &rid).await;
// 关系行是**软删**的(`f_delete_mark = 1`),但角色对 `m_role` 有授权。
link_role_with_delete_mark(db, uid, &rid, "1").await;
grant(db, "role", &rid, M_ROLE).await;
let ids = resolve_user_module_ids(db, uid).await;
assert!(
ids.contains(M_ROLE),
"软删的 base_role_relation 行不过滤 ⇒ 角色授权仍应生效:{ids:?}"
);
}
/// 🔴 钉住「**关系表不过滤 `f_delete_mark`**」(组织 / 岗位侧)。
#[tokio::test]
async fn soft_deleted_user_relation_still_counts() {
let db = db().await;
let _guard = LOCK.lock().await;
ensure_base(db).await.expect("ensure_base 失败");
let uid = "perm_it_softrel_user_user";
let oid = new_uuid();
let pid = new_uuid();
purge(db, uid).await;
purge(db, &oid).await;
purge(db, &pid).await;
// 组织 / 岗位关系行都是**软删**的。
link_user_relation_with_delete_mark(db, uid, "organize", &oid, "1").await;
grant(db, "organize", &oid, M_ORG).await;
link_user_relation_with_delete_mark(db, uid, "position", &pid, "1").await;
grant(db, "position", &pid, M_PRODUCT).await;
let ids = resolve_user_module_ids(db, uid).await;
assert!(
ids.contains(M_ORG),
"软删的 base_user_relation(organize)行不过滤 ⇒ 组织授权仍应生效:{ids:?}"
);
assert!(
ids.contains(M_PRODUCT),
"软删的 base_user_relation(position)行不过滤 ⇒ 岗位授权仍应生效:{ids:?}"
);
}
/// 🔴 钉住 `base_authorize.f_item_type = 'module'`。
///
/// 授权行除了 `f_object_type` 还有 `f_item_type`(`'module'` / `'form'` / `'column'` …)。
/// 若这个条件被去掉,一条 `f_item_type='form'` 的授权会**错误地放行**一个菜单。
#[tokio::test]
async fn non_module_item_type_does_not_grant() {
let db = db().await;
let _guard = LOCK.lock().await;
ensure_base(db).await.expect("ensure_base 失败");
let uid = "perm_it_formtype_user";
purge(db, uid).await;
// 授权行指向 `m_user`,但 `f_item_type` 是 `'form'` ⇒ **不是**菜单授权。
grant_with_item_type(db, "user", uid, M_USER, "form").await;
let ids = resolve_user_module_ids(db, uid).await;
assert!(
!ids.contains(M_USER),
"非 module 的授权不得进合并集合:{ids:?}"
);
assert!(
!has_module(db, uid, 0, "system/User").await,
"只有 f_item_type='module' 的授权才放行菜单"
);
}
// ---- 管理员短路 / 未映射放行 / 已映射未授权 ----
/// 管理员短路:**不给任何授权**也放行(且短路发生在任何 SQL 之前)。
@@ -377,10 +493,13 @@ async fn granted_module_is_allowed_for_non_admin() {
);
}
/// 🔴 **DB 报错 ⇒ 拒**(不是「未映射放行」)。
/// 🔴 **DB 报错 ⇒ 拒**(不是「未映射放行」)+ **管理员在 SQL 之前短路**。
///
/// 这是契约 §9「签名没有 `Result`」的承重分支:DB 挂了不能变成「放行一切」
/// ⇒ 全站越权(且静默)。用「临时删掉 `base_module`」让查菜单这条 SQL 失败。
///
/// 同时钉住「管理员在**任何 SQL 之前**短路」:表被 DROP 的那段时间里,
/// 管理员仍然放行 —— 一个「先查 `base_module`、再看 `is_admin`」的实现会挂。
#[tokio::test]
async fn db_error_denies_instead_of_allowing() {
let db = db().await;
@@ -388,7 +507,9 @@ async fn db_error_denies_instead_of_allowing() {
ensure_base(db).await.expect("ensure_base 失败");
let uid = "perm_it_dberror_user";
let admin_uid = "perm_it_dberror_admin";
purge(db, uid).await;
purge(db, admin_uid).await;
// 让「查菜单」这条 SQL **失败**(表被临时删掉)⇒ 必须走「查询失败 ⇒ 拒」的分支。
db.exec("DROP TABLE base_module")
@@ -396,6 +517,8 @@ async fn db_error_denies_instead_of_allowing() {
.expect("临时删表失败");
let mapped = has_module(db, uid, 0, "system/User").await;
let unmapped = has_module(db, uid, 0, "not/mapped/anywhere").await;
// 🔴 管理员:**SQL 之前**就短路 ⇒ 表都不在也照样放行。
let admin = has_module(db, admin_uid, 1, "system/User").await;
// 🔴 **先恢复表,再断言** —— 断言失败也不会污染同文件的其它测试。
restore_base_module(db).await;
@@ -409,6 +532,10 @@ async fn db_error_denies_instead_of_allowing() {
!unmapped,
"DB 报错必须拒(false)—— 绝不能当成「未映射」放行"
);
assert!(
admin,
"管理员必须在任何 SQL 之前短路放行(查表失败也不影响)"
);
}
/// 把 `base_module` 的建表语句从 `schema.sql` 里捞出来重建(测试专用)。