use crate::account::disable::DefaultDisableRepository;
use crate::config::GarrisonConfig;
use crate::constants::DaoKeyPrefix;
use crate::context::tenant::{TenantContext, TenantSource, TENANT};
use crate::dao::{init_dbnexus, GarrisonDao, GarrisonDaoDbnexus, GarrisonMigration};
use crate::stp::mock::{MockDao, MockInterfaceWithPerms};
use crate::stp::{GarrisonInterface, GarrisonLogicDefault, LoginParams, SessionLogic};
use crate::strategy::{GarrisonPermissionStrategy, GarrisonPermissionStrategyDefault};
use async_trait::async_trait;
use dbnexus::sea_orm::{ConnectionTrait, DbBackend, Statement, Value};
use dbnexus::DbPool;
use std::collections::HashSet;
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_pool() -> DbPool {
let pool = init_dbnexus("sqlite::memory:")
.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
}
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 应成功");
}
fn make_logic(dao: Arc<dyn GarrisonDao>, roles: Vec<String>) -> GarrisonLogicDefault {
let session = Arc::new(crate::session::GarrisonSession::new(
dao.clone(),
3600,
86400,
0,
));
let mut config = GarrisonConfig::default_config();
config.throw_on_not_login = false;
config.token_style = "uuid".to_string();
let interface = Arc::new(MockInterfaceWithPerms {
permissions: vec![],
roles,
});
let firewall: Arc<dyn GarrisonPermissionStrategy> =
Arc::new(GarrisonPermissionStrategyDefault::new(interface));
GarrisonLogicDefault::new(
session,
Arc::new(config),
firewall,
Arc::new(DefaultDisableRepository::new(dao.clone())),
)
}
struct FailingRoleInterface;
#[async_trait]
impl GarrisonInterface for FailingRoleInterface {
async fn get_permission_list(
&self,
_login_id: &str,
) -> crate::error::GarrisonResult<Vec<String>> {
Ok(vec![])
}
async fn get_role_list(&self, _login_id: &str) -> crate::error::GarrisonResult<Vec<String>> {
Err(crate::error::GarrisonError::Internal(
"test-role-source-down::".to_string(),
))
}
}
fn make_logic_with_failing_roles(dao: Arc<dyn GarrisonDao>) -> GarrisonLogicDefault {
let session = Arc::new(crate::session::GarrisonSession::new(
dao.clone(),
3600,
86400,
0,
));
let mut config = GarrisonConfig::default_config();
config.throw_on_not_login = false;
config.token_style = "uuid".to_string();
let firewall: Arc<dyn GarrisonPermissionStrategy> = Arc::new(
GarrisonPermissionStrategyDefault::new(Arc::new(FailingRoleInterface)),
);
GarrisonLogicDefault::new(
session,
Arc::new(config),
firewall,
Arc::new(DefaultDisableRepository::new(dao.clone())),
)
}
async fn read_union(dao: &Arc<dyn GarrisonDao>, login_id: &str) -> Option<HashSet<String>> {
let raw = dao
.get(&DaoKeyPrefix::RoleCache.build_key(login_id))
.await
.expect("dao.get 应成功")?;
Some(serde_json::from_str(&raw).expect("并集缓存应为 JSON 集合"))
}
#[tokio::test(flavor = "multi_thread")]
async fn login_warms_tc_closure_and_union_cache() {
let pool = setup_pool().await;
insert_edge(&pool, 0, "user", "admin").await;
insert_edge(&pool, 0, "admin", "super_admin").await;
let dao: Arc<dyn GarrisonDao> = Arc::new(GarrisonDaoDbnexus::new(
pool,
Arc::new(MockDao::new()) as Arc<dyn GarrisonDao>,
));
let logic = make_logic(dao.clone(), vec!["user".to_string()]);
let _token = logic
.login("alice-ru1", &LoginParams::default())
.await
.expect("login 应成功");
let closure = dao
.get("tenant:0:role_closure")
.await
.expect("dao.get 应成功");
assert!(closure.is_some(), "登录应触发租户 TC 闭包缓存写入");
let union = read_union(&dao, "alice-ru1")
.await
.expect("登录应写入权限并集缓存");
assert!(union.contains("user"), "并集应含直接角色 user");
assert!(union.contains("admin"), "并集应含直接祖先 admin");
assert!(
union.contains("super_admin"),
"并集应含间接祖先 super_admin"
);
assert_eq!(union.len(), 3, "并集应恰为 {{user, admin, super_admin}}");
}
#[tokio::test(flavor = "multi_thread")]
async fn login_union_cache_respects_tenant_context() {
let pool = setup_pool().await;
insert_edge(&pool, 0, "user", "admin").await;
let dao: Arc<dyn GarrisonDao> = Arc::new(GarrisonDaoDbnexus::new(
pool,
Arc::new(MockDao::new()) as Arc<dyn GarrisonDao>,
));
let logic = make_logic(dao.clone(), vec!["user".to_string()]);
let ctx = TenantContext {
tenant_id: 1,
resolved_from: TenantSource::Header,
};
let _token = TENANT
.scope(ctx, logic.login("bob-ru2", &LoginParams::default()))
.await
.expect("租户上下文内 login 应成功");
let closure = dao
.get("tenant:1:role_closure")
.await
.expect("dao.get 应成功");
assert!(closure.is_some(), "登录应在租户 1 维度写 TC 闭包缓存");
let union = read_union(&dao, "bob-ru2")
.await
.expect("登录应写入权限并集缓存");
let expected: HashSet<String> = ["user".to_string()].into_iter().collect();
assert_eq!(union, expected, "租户 1 无继承边,并集应仅含直接角色 user");
}
#[tokio::test(flavor = "multi_thread")]
async fn login_without_sql_backend_fails_open() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let logic = make_logic(dao.clone(), vec!["user".to_string()]);
let _token = logic
.login("carol-ru3", &LoginParams::default())
.await
.expect("无 SQL 后端时 login 仍应成功(fail-open)");
let cached = read_union(&dao, "carol-ru3").await;
assert!(cached.is_none(), "无 SQL 后端时不应写入并集缓存");
}
#[tokio::test(flavor = "multi_thread")]
async fn login_without_roles_skips_union_cache() {
let pool = setup_pool().await;
insert_edge(&pool, 0, "user", "admin").await;
let dao: Arc<dyn GarrisonDao> = Arc::new(GarrisonDaoDbnexus::new(
pool,
Arc::new(MockDao::new()) as Arc<dyn GarrisonDao>,
));
let logic = make_logic(dao.clone(), vec![]);
let _token = logic
.login("dave-ru4", &LoginParams::default())
.await
.expect("无角色时 login 仍应成功");
let union = read_union(&dao, "dave-ru4").await;
assert!(union.is_none(), "无角色时不应写入并集缓存");
let closure = dao
.get("tenant:0:role_closure")
.await
.expect("dao.get 应成功");
assert!(closure.is_none(), "无角色时不应触发 TC 闭包查询");
}
#[tokio::test(flavor = "multi_thread")]
async fn login_with_failing_role_source_fails_open() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let logic = make_logic_with_failing_roles(dao.clone());
let _token = logic
.login("eve-ru5", &LoginParams::default())
.await
.expect("角色源故障时 login 仍应成功(fail-open)");
let cached = read_union(&dao, "eve-ru5").await;
assert!(cached.is_none(), "角色源故障时不应写入并集缓存");
}