#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct RoleHierarchyRecord {
pub child_role: String,
pub parent_role: String,
pub tenant_id: i64,
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
mod service {
use super::RoleHierarchyRecord;
use crate::constants::DaoKeyPrefix;
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
pub struct RoleHierarchyService {
pub dao: Arc<dyn GarrisonDao>,
}
impl RoleHierarchyService {
pub fn new(dao: Arc<dyn GarrisonDao>) -> Self {
Self { dao }
}
async fn query_all_edges(
&self,
tenant_id: i64,
) -> GarrisonResult<Vec<RoleHierarchyRecord>> {
let edges = self.dao.query_role_hierarchy_edges(tenant_id).await?;
Ok(edges
.into_iter()
.map(|(child_role, parent_role)| RoleHierarchyRecord {
child_role,
parent_role,
tenant_id,
})
.collect())
}
pub async fn compute_closure(
&self,
tenant_id: i64,
) -> GarrisonResult<HashMap<String, HashSet<String>>> {
let edges = self.query_all_edges(tenant_id).await?;
let mut adj: HashMap<String, Vec<String>> = HashMap::new();
for edge in &edges {
adj.entry(edge.child_role.clone())
.or_default()
.push(edge.parent_role.clone());
}
let mut closure: HashMap<String, HashSet<String>> = HashMap::new();
let mut memo: HashMap<String, HashSet<String>> = HashMap::new();
for child in adj.keys() {
let (ancestors, _complete) =
Self::dfs_ancestors(child, &adj, &mut HashSet::new(), &mut memo);
closure.insert(child.clone(), ancestors);
}
Ok(closure)
}
fn dfs_ancestors(
role: &str,
adj: &HashMap<String, Vec<String>>,
visited: &mut HashSet<String>,
memo: &mut HashMap<String, HashSet<String>>,
) -> (HashSet<String>, bool) {
let mut ancestors = HashSet::new();
if visited.contains(role) {
return (ancestors, false); }
if let Some(cached) = memo.get(role) {
return (cached.clone(), true);
}
visited.insert(role.to_string());
let mut complete = true;
if let Some(parents) = adj.get(role) {
for parent in parents {
if visited.contains(parent) {
complete = false;
continue;
}
ancestors.insert(parent.clone());
let (indirect, sub_complete) = Self::dfs_ancestors(parent, adj, visited, memo);
complete &= sub_complete;
ancestors.extend(indirect);
}
}
visited.remove(role); if complete {
memo.insert(role.to_string(), ancestors.clone());
}
(ancestors, complete)
}
pub async fn get_ancestors(
&self,
role: &str,
tenant_id: i64,
) -> GarrisonResult<HashSet<String>> {
let cache_key = format!("{}{}:role_closure", DaoKeyPrefix::Tenant, tenant_id);
if let Some(cached) = self.dao.get(&cache_key).await? {
if let Ok(closure) =
serde_json::from_str::<HashMap<String, HashSet<String>>>(&cached)
{
return Ok(closure.get(role).cloned().unwrap_or_default());
}
}
let closure = self.compute_closure(tenant_id).await?;
let json = serde_json::to_string(&closure)
.map_err(|e| GarrisonError::Dao(format!("dao-role-closure-serialize::{}", e)))?;
self.dao.set(&cache_key, &json, 3600).await?;
Ok(closure.get(role).cloned().unwrap_or_default())
}
pub async fn add_edge(
&self,
child: &str,
parent: &str,
tenant_id: i64,
) -> GarrisonResult<()> {
if child == parent {
return Err(GarrisonError::InvalidParam(format!(
"dao-role-hierarchy-self-loop::{}",
child
)));
}
self.dao
.insert_role_hierarchy_edge(tenant_id, child, parent)
.await?;
self.invalidate_cache(tenant_id).await
}
pub async fn invalidate_cache(&self, tenant_id: i64) -> GarrisonResult<()> {
let cache_key = format!("{}{}:role_closure", DaoKeyPrefix::Tenant, tenant_id);
self.dao.delete(&cache_key).await
}
pub async fn get_descendants(
&self,
role: &str,
tenant_id: i64,
) -> GarrisonResult<HashSet<String>> {
let edges = self.query_all_edges(tenant_id).await?;
let mut reverse_adj: HashMap<String, Vec<String>> = HashMap::new();
for edge in &edges {
reverse_adj
.entry(edge.parent_role.clone())
.or_default()
.push(edge.child_role.clone());
}
let descendants = Self::dfs_descendants(role, &reverse_adj, &mut HashSet::new());
Ok(descendants)
}
fn dfs_descendants(
role: &str,
reverse_adj: &HashMap<String, Vec<String>>,
visited: &mut HashSet<String>,
) -> HashSet<String> {
let mut descendants = HashSet::new();
if visited.contains(role) {
return descendants; }
visited.insert(role.to_string());
if let Some(children) = reverse_adj.get(role) {
for child in children {
if visited.contains(child) {
continue;
}
descendants.insert(child.clone());
let indirect = Self::dfs_descendants(child, reverse_adj, visited);
descendants.extend(indirect);
}
}
visited.remove(role);
descendants
}
}
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
pub use service::RoleHierarchyService;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn role_hierarchy_record_constructs_with_role_parent_tenant() {
let record = RoleHierarchyRecord {
child_role: "user".to_string(),
parent_role: "admin".to_string(),
tenant_id: 0,
};
assert_eq!(record.child_role, "user");
assert_eq!(record.parent_role, "admin");
assert_eq!(record.tenant_id, 0);
}
#[test]
fn role_hierarchy_record_derives_clone_debug_eq_serde() {
let r1 = RoleHierarchyRecord {
child_role: "user".to_string(),
parent_role: "admin".to_string(),
tenant_id: 0,
};
let r2 = r1.clone();
assert_eq!(r1, r2);
let json = serde_json::to_string(&r1).unwrap();
let r3: RoleHierarchyRecord = serde_json::from_str(&json).unwrap();
assert_eq!(r1, r3);
let _debug = format!("{:?}", r1);
}
#[cfg(all(test, any(feature = "db-postgres", feature = "db-mysql")))]
#[test]
fn role_hierarchy_service_compiles_under_postgres_and_mysql() {
let _: Option<RoleHierarchyService> = None;
}
}
#[cfg(all(test, feature = "db-sqlite"))]
mod db_sqlite_tests {
use super::*;
use crate::dao::{init_dbnexus, GarrisonDao, GarrisonDaoDbnexus, GarrisonMigration};
use dbnexus::sea_orm::{ConnectionTrait, DbBackend, Statement, Value};
use dbnexus::DbPool;
use std::path::PathBuf;
use std::sync::Arc;
fn project_migrations_dir() -> PathBuf {
let manifest_dir = env!("CARGO_MANIFEST_DIR");
PathBuf::from(manifest_dir)
.join("migrations")
.join("sqlite")
}
async fn setup_db() -> DbPool {
static SEQ: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
let db_id = SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let pool = init_dbnexus(&format!(
"sqlite://garrison_role_hierarchy_{db_id}?mode=memory&cache=shared"
))
.await
.expect("init_dbnexus 应成功");
let migration = GarrisonMigration::with_base_dir(pool.clone(), project_migrations_dir());
let applied = migration.migrate_core().await.expect("migrate_core 应成功");
assert!(applied >= 1, "migrate_core 应至少执行 1 个文件");
pool
}
fn mock_dao() -> Arc<dyn GarrisonDao> {
Arc::new(crate::dao::tests::MockDao::new())
}
async fn setup_dao(pool: DbPool) -> Arc<dyn GarrisonDao> {
let kv = mock_dao();
Arc::new(GarrisonDaoDbnexus::new(pool, kv))
}
async fn insert_edge(pool: &DbPool, tenant_id: i64, child_role: &str, parent_role: &str) {
let session = pool.get_session("admin").await.unwrap();
let conn = session.connection().unwrap();
let stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"INSERT OR IGNORE INTO role_hierarchy (tenant_id, child_role, parent_role) VALUES (?, ?, ?)",
vec![
Value::BigInt(Some(tenant_id)),
Value::String(Some(child_role.to_string())),
Value::String(Some(parent_role.to_string())),
],
);
conn.execute_raw(stmt).await.expect("INSERT 应成功");
}
#[tokio::test(flavor = "multi_thread")]
async fn role_hierarchy_table_exists_after_migration() {
let pool = setup_db().await;
let session = pool.get_session("admin").await.unwrap();
let conn = session.connection().unwrap();
let stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"SELECT name FROM sqlite_master WHERE type='table' AND name='role_hierarchy'",
vec![],
);
let rows = conn.query_all_raw(stmt).await.expect("query_all 应成功");
assert_eq!(
rows.len(),
1,
"role_hierarchy 表应存在(迁移后 sqlite_master 应有 1 行记录)"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn compute_closure_returns_indirect_ancestors() {
let pool = setup_db().await;
insert_edge(&pool, 0, "user", "admin").await;
insert_edge(&pool, 0, "admin", "super_admin").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let closure = svc
.compute_closure(0)
.await
.expect("compute_closure 应成功");
let user_ancestors = closure.get("user").expect("closure 应包含 user 的祖先集合");
assert!(
user_ancestors.contains("admin"),
"user 的祖先应含 admin(直接父角色)"
);
assert!(
user_ancestors.contains("super_admin"),
"user 的祖先应含 super_admin(间接祖先)"
);
let admin_ancestors = closure
.get("admin")
.expect("closure 应包含 admin 的祖先集合");
assert!(
admin_ancestors.contains("super_admin"),
"admin 的祖先应含 super_admin(直接父角色)"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn compute_closure_empty_table_returns_empty_map() {
let pool = setup_db().await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let closure = svc
.compute_closure(0)
.await
.expect("compute_closure 应成功");
assert!(closure.is_empty(), "空表应返回空 HashMap");
}
#[tokio::test(flavor = "multi_thread")]
async fn compute_closure_filters_by_tenant_id() {
let pool = setup_db().await;
insert_edge(&pool, 0, "user", "admin").await;
insert_edge(&pool, 1, "user", "super_admin").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let closure_0 = svc
.compute_closure(0)
.await
.expect("compute_closure(0) 应成功");
let user_ancestors_0 = closure_0.get("user").expect("tenant 0 应有 user");
assert!(user_ancestors_0.contains("admin"));
assert!(!user_ancestors_0.contains("super_admin"));
let closure_1 = svc
.compute_closure(1)
.await
.expect("compute_closure(1) 应成功");
let user_ancestors_1 = closure_1.get("user").expect("tenant 1 应有 user");
assert!(user_ancestors_1.contains("super_admin"));
assert!(!user_ancestors_1.contains("admin"));
}
#[tokio::test(flavor = "multi_thread")]
async fn compute_closure_handles_cycle_without_infinite_recursion() {
let pool = setup_db().await;
insert_edge(&pool, 0, "A", "B").await;
insert_edge(&pool, 0, "B", "A").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let closure = svc
.compute_closure(0)
.await
.expect("compute_closure 应成功");
let a_ancestors = closure.get("A").expect("closure 应包含 A");
assert!(a_ancestors.contains("B"));
let b_ancestors = closure.get("B").expect("closure 应包含 B");
assert!(b_ancestors.contains("A"));
}
#[tokio::test(flavor = "multi_thread")]
async fn get_ancestors_returns_cached_closure() {
let pool = setup_db().await;
let dao = setup_dao(pool.clone()).await;
insert_edge(&pool, 0, "user", "admin").await;
insert_edge(&pool, 0, "admin", "super_admin").await;
let svc = RoleHierarchyService::new(dao.clone());
let ancestors = svc
.get_ancestors("user", 0)
.await
.expect("get_ancestors 应成功");
assert!(ancestors.contains("admin"), "应含 admin(直接父角色)");
assert!(
ancestors.contains("super_admin"),
"应含 super_admin(间接祖先)"
);
let cached = dao
.get("tenant:0:role_closure")
.await
.expect("dao.get 应成功");
assert!(cached.is_some(), "oxcache 应已缓存 role_closure");
}
#[tokio::test(flavor = "multi_thread")]
async fn add_edge_invalidates_cache() {
let pool = setup_db().await;
let dao = setup_dao(pool.clone()).await;
insert_edge(&pool, 0, "user", "admin").await;
let svc = RoleHierarchyService::new(dao.clone());
let _ = svc
.get_ancestors("user", 0)
.await
.expect("get_ancestors 应成功");
let cached_before = dao
.get("tenant:0:role_closure")
.await
.expect("dao.get 应成功");
assert!(cached_before.is_some(), "前置条件:缓存应已写入");
svc.add_edge("user", "super_admin", 0)
.await
.expect("add_edge 应成功");
let cached_after = dao
.get("tenant:0:role_closure")
.await
.expect("dao.get 应成功");
assert!(cached_after.is_none(), "add_edge 后缓存应已失效");
}
#[tokio::test(flavor = "multi_thread")]
async fn add_edge_reflects_in_subsequent_get_ancestors() {
let pool = setup_db().await;
let dao = setup_dao(pool.clone()).await;
insert_edge(&pool, 0, "user", "admin").await;
let svc = RoleHierarchyService::new(dao.clone());
let ancestors1 = svc
.get_ancestors("user", 0)
.await
.expect("get_ancestors 应成功");
assert!(ancestors1.contains("admin"));
assert!(!ancestors1.contains("super_admin"));
svc.add_edge("user", "super_admin", 0)
.await
.expect("add_edge 应成功");
let ancestors2 = svc
.get_ancestors("user", 0)
.await
.expect("get_ancestors 应成功");
assert!(ancestors2.contains("admin"));
assert!(ancestors2.contains("super_admin"));
}
#[tokio::test(flavor = "multi_thread")]
async fn get_ancestors_cache_hit_does_not_query_db() {
let pool = setup_db().await;
let dao = setup_dao(pool.clone()).await;
insert_edge(&pool, 0, "user", "admin").await;
let svc = RoleHierarchyService::new(dao.clone());
let ancestors1 = svc
.get_ancestors("user", 0)
.await
.expect("get_ancestors 应成功");
assert!(ancestors1.contains("admin"));
let session = pool.get_session("admin").await.unwrap();
let conn = session.connection().unwrap();
conn.execute_raw(Statement::from_sql_and_values(
DbBackend::Sqlite,
"DELETE FROM role_hierarchy",
vec![],
))
.await
.expect("DELETE 应成功");
let ancestors2 = svc
.get_ancestors("user", 0)
.await
.expect("缓存命中时 get_ancestors 应成功");
assert!(
ancestors2.contains("admin"),
"缓存命中应返回与首次相同的结果"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn get_ancestors_corrupt_cache_falls_back_to_recompute() {
let pool = setup_db().await;
let dao = setup_dao(pool.clone()).await;
insert_edge(&pool, 0, "user", "admin").await;
let svc = RoleHierarchyService::new(dao.clone());
dao.set("tenant:0:role_closure", "{invalid json", 3600)
.await
.expect("注入损坏缓存应成功");
let ancestors = svc
.get_ancestors("user", 0)
.await
.expect("降级重新计算应成功");
assert!(ancestors.contains("admin"), "降级重新计算后应返回正确结果");
let cached = dao
.get("tenant:0:role_closure")
.await
.expect("dao.get 应成功");
assert!(cached.is_some(), "缓存应已被重新写入");
let closure: std::collections::HashMap<String, std::collections::HashSet<String>> =
serde_json::from_str(&cached.unwrap()).expect("缓存应为有效 JSON");
assert!(closure.contains_key("user"), "闭包应包含 user");
}
#[tokio::test(flavor = "multi_thread")]
async fn get_ancestors_for_nonexistent_role_returns_empty() {
let pool = setup_db().await;
let dao = setup_dao(pool.clone()).await;
insert_edge(&pool, 0, "user", "admin").await;
let svc = RoleHierarchyService::new(dao.clone());
let ancestors = svc
.get_ancestors("nonexistent_role", 0)
.await
.expect("get_ancestors 应成功");
assert!(ancestors.is_empty(), "不存在的角色应返回空祖先集合");
}
#[tokio::test(flavor = "multi_thread")]
async fn invalidate_cache_is_idempotent() {
let pool = setup_db().await;
let dao = setup_dao(pool.clone()).await;
let svc = RoleHierarchyService::new(dao.clone());
let result = svc.invalidate_cache(999).await;
assert!(result.is_ok(), "invalidate_cache 不存在的缓存应幂等返回 Ok");
let result2 = svc.invalidate_cache(999).await;
assert!(result2.is_ok(), "多次调用 invalidate_cache 应幂等");
}
#[tokio::test(flavor = "multi_thread")]
async fn get_descendants_returns_indirect_descendants() {
let pool = setup_db().await;
insert_edge(&pool, 0, "user", "admin").await;
insert_edge(&pool, 0, "admin", "super_admin").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let descendants = svc
.get_descendants("super_admin", 0)
.await
.expect("get_descendants 应成功");
assert!(
descendants.contains("admin"),
"super_admin 的后代应含 admin(直接子角色)"
);
assert!(
descendants.contains("user"),
"super_admin 的后代应含 user(间接后代)"
);
let admin_descendants = svc
.get_descendants("admin", 0)
.await
.expect("get_descendants 应成功");
assert!(admin_descendants.contains("user"), "admin 的后代应含 user");
assert!(
!admin_descendants.contains("super_admin"),
"admin 的后代不应含 super_admin(方向相反)"
);
let user_descendants = svc
.get_descendants("user", 0)
.await
.expect("get_descendants 应成功");
assert!(
user_descendants.is_empty(),
"user 无后代(user 是最底层角色)"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn get_descendants_empty_table_returns_empty() {
let pool = setup_db().await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let descendants = svc
.get_descendants("any_role", 0)
.await
.expect("get_descendants 应成功");
assert!(descendants.is_empty(), "空表应返回空后代集合");
}
#[tokio::test(flavor = "multi_thread")]
async fn get_descendants_handles_cycle_without_infinite_recursion() {
let pool = setup_db().await;
insert_edge(&pool, 0, "A", "B").await;
insert_edge(&pool, 0, "B", "A").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let descendants_a = svc
.get_descendants("A", 0)
.await
.expect("get_descendants 应成功");
assert!(descendants_a.contains("B"), "A 的后代应含 B");
let descendants_b = svc
.get_descendants("B", 0)
.await
.expect("get_descendants 应成功");
assert!(descendants_b.contains("A"), "B 的后代应含 A");
}
#[tokio::test(flavor = "multi_thread")]
async fn get_descendants_filters_by_tenant_id() {
let pool = setup_db().await;
insert_edge(&pool, 0, "user", "admin").await;
insert_edge(&pool, 1, "user", "super_admin").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let desc_0 = svc
.get_descendants("admin", 0)
.await
.expect("get_descendants(0) 应成功");
assert!(desc_0.contains("user"), "tenant 0: admin 的后代应含 user");
assert!(
!desc_0.contains("super_admin"),
"tenant 0: admin 的后代不应含 super_admin"
);
let desc_1 = svc
.get_descendants("super_admin", 1)
.await
.expect("get_descendants(1) 应成功");
assert!(
desc_1.contains("user"),
"tenant 1: super_admin 的后代应含 user"
);
assert!(
!desc_1.contains("admin"),
"tenant 1: super_admin 的后代不应含 admin"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn get_descendants_for_nonexistent_role_returns_empty() {
let pool = setup_db().await;
insert_edge(&pool, 0, "user", "admin").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let descendants = svc
.get_descendants("nonexistent_role", 0)
.await
.expect("get_descendants 应成功");
assert!(descendants.is_empty(), "不存在的角色应返回空后代集合");
}
#[tokio::test(flavor = "multi_thread")]
async fn get_descendants_handles_diamond_inheritance() {
let pool = setup_db().await;
insert_edge(&pool, 0, "D", "B").await;
insert_edge(&pool, 0, "B", "A").await;
insert_edge(&pool, 0, "D", "C").await;
insert_edge(&pool, 0, "C", "A").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let descendants = svc
.get_descendants("A", 0)
.await
.expect("get_descendants 应成功");
assert!(descendants.contains("B"), "A 的后代应含 B");
assert!(descendants.contains("C"), "A 的后代应含 C");
assert!(descendants.contains("D"), "A 的后代应含 D");
let b_descendants = svc
.get_descendants("B", 0)
.await
.expect("get_descendants 应成功");
assert!(b_descendants.contains("D"), "B 的后代应含 D");
assert!(!b_descendants.contains("A"), "B 的后代不应含 A");
}
#[tokio::test(flavor = "multi_thread")]
async fn add_edge_is_idempotent() {
let pool = setup_db().await;
let dao = setup_dao(pool.clone()).await;
let svc = RoleHierarchyService::new(dao);
svc.add_edge("user", "admin", 0)
.await
.expect("第一次 add_edge 应成功");
let result = svc.add_edge("user", "admin", 0).await;
assert!(result.is_ok(), "重复插入相同边应幂等返回 Ok");
let session = pool.get_session("admin").await.unwrap();
let conn = session.connection().unwrap();
let stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"SELECT COUNT(*) as cnt FROM role_hierarchy WHERE tenant_id = 0 AND child_role = 'user' AND parent_role = 'admin'",
vec![],
);
let rows = conn.query_all_raw(stmt).await.expect("COUNT 查询应成功");
let count: i64 = rows[0].try_get::<i64>("", "cnt").expect("读取 cnt 应成功");
assert_eq!(count, 1, "重复插入后应只有 1 条记录(INSERT OR IGNORE)");
}
#[tokio::test(flavor = "multi_thread")]
async fn add_edge_rejects_self_loop() {
let pool = setup_db().await;
let dao = setup_dao(pool.clone()).await;
let svc = RoleHierarchyService::new(dao);
let result = svc.add_edge("A", "A", 0).await;
assert!(
matches!(
result,
Err(crate::error::GarrisonError::InvalidParam(ref msg))
if msg.contains("dao-role-hierarchy-self-loop")
),
"自环边应返回含 'dao-role-hierarchy-self-loop' 的 InvalidParam 错误,实际: {:?}",
result
);
let session = pool.get_session("admin").await.unwrap();
let conn = session.connection().unwrap();
let stmt = Statement::from_sql_and_values(
DbBackend::Sqlite,
"SELECT COUNT(*) as cnt FROM role_hierarchy WHERE child_role = 'A' AND parent_role = 'A'",
vec![],
);
let rows = conn.query_all_raw(stmt).await.expect("COUNT 查询应成功");
let count: i64 = rows[0].try_get::<i64>("", "cnt").expect("读取 cnt 应成功");
assert_eq!(count, 0, "自环边不应入库");
}
#[tokio::test(flavor = "multi_thread")]
async fn compute_closure_diamond_inheritance_collects_all_ancestors() {
let pool = setup_db().await;
insert_edge(&pool, 0, "D", "B").await;
insert_edge(&pool, 0, "B", "A").await;
insert_edge(&pool, 0, "D", "C").await;
insert_edge(&pool, 0, "C", "A").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let closure = svc
.compute_closure(0)
.await
.expect("compute_closure 应成功");
let d_ancestors = closure.get("D").expect("closure 应包含 D");
assert!(d_ancestors.contains("B"), "D 的祖先应含 B");
assert!(d_ancestors.contains("C"), "D 的祖先应含 C");
assert!(
d_ancestors.contains("A"),
"D 的祖先应含 A(菱形继承的顶点)"
);
assert_eq!(
d_ancestors.len(),
3,
"D 的祖先应为 {{B, C, A}}(去重后 3 个)"
);
let b_ancestors = closure.get("B").expect("closure 应包含 B");
assert!(b_ancestors.contains("A"), "B 的祖先应含 A");
assert!(!b_ancestors.contains("C"), "B 的祖先不应含 C");
assert!(!b_ancestors.contains("D"), "B 的祖先不应含 D");
}
#[tokio::test(flavor = "multi_thread")]
async fn compute_closure_self_loop_does_not_infinite_recurse() {
let pool = setup_db().await;
insert_edge(&pool, 0, "A", "A").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let closure = svc
.compute_closure(0)
.await
.expect("compute_closure 应成功");
let a_ancestors = closure
.get("A")
.expect("closure 应包含 A(自环边使 A 在 adj 中)");
assert!(
!a_ancestors.contains("A"),
"自环 A->A 时 A 不应出现在自身祖先集合中"
);
assert!(a_ancestors.is_empty(), "自环 A 的祖先集合应为空");
}
#[tokio::test(flavor = "multi_thread")]
async fn compute_closure_multiple_disconnected_components() {
let pool = setup_db().await;
insert_edge(&pool, 0, "A", "B").await;
insert_edge(&pool, 0, "C", "D").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let closure = svc
.compute_closure(0)
.await
.expect("compute_closure 应成功");
assert_eq!(closure.len(), 2, "应有两个不连通分量(A 和 C)");
let a_ancestors = closure.get("A").expect("closure 应包含 A");
assert!(a_ancestors.contains("B"), "A 的祖先应含 B");
assert!(!a_ancestors.contains("D"), "A 的祖先不应含 D(不连通)");
let c_ancestors = closure.get("C").expect("closure 应包含 C");
assert!(c_ancestors.contains("D"), "C 的祖先应含 D");
assert!(!c_ancestors.contains("B"), "C 的祖先不应含 B(不连通)");
}
#[tokio::test(flavor = "multi_thread")]
async fn compute_closure_multi_level_chain_collects_all_ancestors() {
let pool = setup_db().await;
insert_edge(&pool, 0, "L0", "L1").await;
insert_edge(&pool, 0, "L1", "L2").await;
insert_edge(&pool, 0, "L2", "L3").await;
insert_edge(&pool, 0, "L3", "L4").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let closure = svc
.compute_closure(0)
.await
.expect("compute_closure 应成功");
let l0_ancestors = closure.get("L0").expect("closure 应包含 L0");
assert_eq!(
l0_ancestors.len(),
4,
"L0 的祖先应含 L1, L2, L3, L4(共 4 个)"
);
assert!(l0_ancestors.contains("L1"));
assert!(l0_ancestors.contains("L2"));
assert!(l0_ancestors.contains("L3"));
assert!(l0_ancestors.contains("L4"));
let l3_ancestors = closure.get("L3").expect("closure 应包含 L3");
assert!(
l3_ancestors.contains("L4"),
"L3 的祖先应含 L4(直接父角色)"
);
assert_eq!(l3_ancestors.len(), 1, "L3 的祖先应只有 L4");
}
#[tokio::test(flavor = "multi_thread")]
async fn get_ancestors_second_role_hits_cached_closure() {
let pool = setup_db().await;
let dao = setup_dao(pool.clone()).await;
insert_edge(&pool, 0, "user", "admin").await;
insert_edge(&pool, 0, "reader", "viewer").await;
let svc = RoleHierarchyService::new(dao.clone());
let user_ancestors = svc
.get_ancestors("user", 0)
.await
.expect("首次 get_ancestors(user) 应成功");
assert!(user_ancestors.contains("admin"));
let session = pool.get_session("admin").await.unwrap();
let conn = session.connection().unwrap();
conn.execute_raw(Statement::from_sql_and_values(
DbBackend::Sqlite,
"DELETE FROM role_hierarchy",
vec![],
))
.await
.expect("DELETE 应成功");
let reader_ancestors = svc
.get_ancestors("reader", 0)
.await
.expect("缓存命中时 get_ancestors(reader) 应成功");
assert!(
reader_ancestors.contains("viewer"),
"缓存命中时应返回 reader 的祖先 viewer"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn add_edge_invalidates_only_same_tenant_cache() {
let pool = setup_db().await;
let dao = setup_dao(pool.clone()).await;
insert_edge(&pool, 0, "user0", "admin0").await;
insert_edge(&pool, 1, "user1", "admin1").await;
let svc = RoleHierarchyService::new(dao.clone());
svc.get_ancestors("user0", 0)
.await
.expect("tenant 0 首次查询应成功");
svc.get_ancestors("user1", 1)
.await
.expect("tenant 1 首次查询应成功");
assert!(
dao.get("tenant:0:role_closure").await.unwrap().is_some(),
"tenant 0 缓存应已写入"
);
assert!(
dao.get("tenant:1:role_closure").await.unwrap().is_some(),
"tenant 1 缓存应已写入"
);
svc.add_edge("user1", "super_admin1", 1)
.await
.expect("add_edge(tenant 1) 应成功");
assert!(
dao.get("tenant:0:role_closure").await.unwrap().is_some(),
"tenant 0 缓存应仍存在(跨租户隔离)"
);
assert!(
dao.get("tenant:1:role_closure").await.unwrap().is_none(),
"tenant 1 缓存应已失效"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn get_descendants_self_loop_does_not_infinite_recurse() {
let pool = setup_db().await;
insert_edge(&pool, 0, "A", "A").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let descendants = svc
.get_descendants("A", 0)
.await
.expect("get_descendants 应成功");
assert!(
!descendants.contains("A"),
"自环 A->A 时 A 不应出现在自身后代集合中"
);
assert!(descendants.is_empty(), "自环 A 的后代集合应为空");
}
#[tokio::test(flavor = "multi_thread")]
async fn get_descendants_multi_parent_child_appears_under_all_parents() {
let pool = setup_db().await;
insert_edge(&pool, 0, "user", "admin").await;
insert_edge(&pool, 0, "user", "manager").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let admin_desc = svc
.get_descendants("admin", 0)
.await
.expect("get_descendants(admin) 应成功");
assert!(
admin_desc.contains("user"),
"admin 的后代应含 user(user 继承 admin)"
);
let mgr_desc = svc
.get_descendants("manager", 0)
.await
.expect("get_descendants(manager) 应成功");
assert!(
mgr_desc.contains("user"),
"manager 的后代应含 user(user 继承 manager)"
);
let user_desc = svc
.get_descendants("user", 0)
.await
.expect("get_descendants(user) 应成功");
assert!(user_desc.is_empty(), "user 无后代");
}
#[tokio::test(flavor = "multi_thread")]
async fn compute_closure_multi_parent_collects_all_parents() {
let pool = setup_db().await;
insert_edge(&pool, 0, "user", "admin").await;
insert_edge(&pool, 0, "user", "super_admin").await;
let svc = RoleHierarchyService::new(setup_dao(pool).await);
let closure = svc
.compute_closure(0)
.await
.expect("compute_closure 应成功");
let user_ancestors = closure.get("user").expect("closure 应包含 user");
assert!(user_ancestors.contains("admin"), "user 的祖先应含 admin");
assert!(
user_ancestors.contains("super_admin"),
"user 的祖先应含 super_admin"
);
assert_eq!(
user_ancestors.len(),
2,
"user 的祖先应为 {{admin, super_admin}}(共 2 个)"
);
}
}