use crate::error::{GarrisonError, GarrisonResult};
use crate::stp::{with_current_token, GarrisonUtil};
use async_trait::async_trait;
#[async_trait]
pub trait ParameterQuery: Send + Sync {
fn with_login_id(self, login_id: String) -> Self;
fn with_device(self, device: &str) -> Self;
fn with_token(self, token: &str) -> Self;
async fn check_permission(&self, perm: &str) -> GarrisonResult<()>;
async fn check_role(&self, role: &str) -> GarrisonResult<()>;
}
pub struct ParameterQueryBuilder {
login_id: Option<String>,
device: Option<String>,
token: Option<String>,
}
impl ParameterQueryBuilder {
pub fn new() -> Self {
Self {
login_id: None,
device: None,
token: None,
}
}
async fn check_common(&self, value: &str, kind: CheckKind) -> GarrisonResult<()> {
if let Some(token) = &self.token {
let token = token.clone();
let value = value.to_string();
with_current_token(token, async move {
match kind {
CheckKind::Permission => GarrisonUtil::check_permission(&value).await,
CheckKind::Role => GarrisonUtil::check_role(&value).await,
}
})
.await
} else if let Some(login_id) = &self.login_id {
let token = GarrisonUtil::login_simple(login_id).await?;
let value = value.to_string();
let token_for_cleanup = token.clone();
let result = with_current_token(token, async move {
match kind {
CheckKind::Permission => GarrisonUtil::check_permission(&value).await,
CheckKind::Role => GarrisonUtil::check_role(&value).await,
}
})
.await;
if let Err(e) = GarrisonUtil::kickout_by_token(&token_for_cleanup).await {
tracing::warn!(
error = %e,
"ParameterQuery temporary session cleanup failed (non-fatal, TTL will clean it up)"
);
}
result
} else {
Err(GarrisonError::Internal(
"stp-param-login-id-missing::".to_string(),
))
}
}
}
impl Default for ParameterQueryBuilder {
fn default() -> Self {
Self::new()
}
}
enum CheckKind {
Permission,
Role,
}
#[async_trait]
impl ParameterQuery for ParameterQueryBuilder {
fn with_login_id(mut self, login_id: String) -> Self {
self.login_id = Some(login_id);
self
}
fn with_device(mut self, device: &str) -> Self {
self.device = Some(device.to_string());
self
}
fn with_token(mut self, token: &str) -> Self {
self.token = Some(token.to_string());
self
}
async fn check_permission(&self, perm: &str) -> GarrisonResult<()> {
self.check_common(perm, CheckKind::Permission).await
}
async fn check_role(&self, role: &str) -> GarrisonResult<()> {
self.check_common(role, CheckKind::Role).await
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::GarrisonConfig;
use crate::context::tenant::with_default_tenant;
use crate::dao::GarrisonDao;
use crate::manager::GarrisonManager;
use crate::stp::GarrisonInterface;
use async_trait::async_trait;
use parking_lot::Mutex;
use serial_test::serial;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::{Duration, Instant};
struct MockDao {
store: Mutex<HashMap<String, (String, Option<Instant>)>>,
}
impl MockDao {
fn new() -> Self {
Self {
store: Mutex::new(HashMap::new()),
}
}
}
#[async_trait]
impl GarrisonDao for MockDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
let mut store = self.store.lock();
match store.get(key) {
Some((value, expire_at)) => {
if let Some(deadline) = expire_at {
if Instant::now() >= *deadline {
store.remove(key);
return Ok(None);
}
}
Ok(Some(value.clone()))
},
None => Ok(None),
}
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
let expire_at = if ttl_seconds == 0 {
None
} else {
Some(Instant::now() + Duration::from_secs(ttl_seconds))
};
self.store
.lock()
.insert(key.to_string(), (value.to_string(), expire_at));
Ok(())
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
let mut store = self.store.lock();
match store.get_mut(key) {
Some((existing, _)) => {
*existing = value.to_string();
Ok(())
},
None => Err(GarrisonError::Dao(format!("dao-key-not-found::{}", key))),
}
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
let mut store = self.store.lock();
match store.get_mut(key) {
Some((_, expire_at)) => {
*expire_at = if seconds == 0 {
None
} else {
Some(Instant::now() + Duration::from_secs(seconds))
};
Ok(())
},
None => Err(GarrisonError::Dao(format!("dao-key-not-found::{}", key))),
}
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
self.store.lock().remove(key);
Ok(())
}
crate::atomic_test_fallback!();
}
struct MockInterfaceWithPerms {
permissions: HashMap<String, Vec<String>>,
roles: HashMap<String, Vec<String>>,
}
#[async_trait]
impl GarrisonInterface for MockInterfaceWithPerms {
async fn get_permission_list(&self, login_id: &str) -> GarrisonResult<Vec<String>> {
Ok(self.permissions.get(login_id).cloned().unwrap_or_default())
}
async fn get_role_list(&self, login_id: &str) -> GarrisonResult<Vec<String>> {
Ok(self.roles.get(login_id).cloned().unwrap_or_default())
}
}
async fn init_manager_with_perms(
throw_on_not_login: bool,
permissions: HashMap<String, Vec<String>>,
roles: HashMap<String, Vec<String>>,
) {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let mut config = GarrisonConfig::default_config();
config.timeout = 3600;
config.active_timeout = -1;
config.throw_on_not_login = throw_on_not_login;
let interface: Arc<dyn GarrisonInterface> =
Arc::new(MockInterfaceWithPerms { permissions, roles });
GarrisonManager::builder()
.dao(dao)
.config(Arc::new(config))
.interface(interface)
.build()
.await
.unwrap();
}
#[test]
fn builder_new_has_no_context() {
let builder = ParameterQueryBuilder::new();
assert!(builder.login_id.is_none(), "new() 后 login_id 应为 None");
assert!(builder.device.is_none(), "new() 后 device 应为 None");
assert!(builder.token.is_none(), "new() 后 token 应为 None");
}
#[test]
fn with_login_id_sets_context() {
let builder = ParameterQueryBuilder::new().with_login_id("1001".to_string());
assert_eq!(builder.login_id, Some("1001".to_string()));
}
#[serial]
#[test]
fn with_device_sets_context() {
let builder = ParameterQueryBuilder::new().with_device("dev1");
assert_eq!(builder.device.as_deref(), Some("dev1"));
}
#[serial]
#[test]
fn with_token_sets_context() {
let builder = ParameterQueryBuilder::new().with_token("abc-token");
assert_eq!(builder.token.as_deref(), Some("abc-token"));
}
#[serial]
#[test]
fn chain_with_login_id_and_device_sets_context() {
let builder = ParameterQueryBuilder::new()
.with_login_id("1001".to_string())
.with_device("dev1");
assert_eq!(
builder.login_id,
Some("1001".to_string()),
"链式调用后 login_id 应为 1001"
);
assert_eq!(
builder.device.as_deref(),
Some("dev1"),
"链式调用后 device 应为 dev1"
);
}
#[tokio::test]
#[serial]
async fn check_permission_without_context_returns_internal() {
GarrisonManager::reset_for_test();
let builder = ParameterQueryBuilder::new();
let result = builder.check_permission("user:create").await;
assert!(
matches!(result, Err(GarrisonError::Internal(ref msg)) if msg.contains("stp-param-login-id-missing")),
"未设置上下文时应返回 Internal 错误,实际: {:?}",
result
);
}
#[tokio::test]
#[serial]
async fn check_permission_with_login_id_succeeds_when_authorized() {
let mut perms = HashMap::new();
perms.insert("1001".to_string(), vec!["user:create".to_string()]);
init_manager_with_perms(false, perms, HashMap::new()).await;
let result = with_default_tenant(async {
ParameterQueryBuilder::new()
.with_login_id("1001".to_string())
.check_permission("user:create")
.await
})
.await;
assert!(result.is_ok(), "持有权限时应返回 Ok,实际: {:?}", result);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_permission_with_login_id_returns_not_permission_when_denied() {
let perms: HashMap<String, Vec<String>> = HashMap::new();
init_manager_with_perms(false, perms, HashMap::new()).await;
let result = with_default_tenant(async {
ParameterQueryBuilder::new()
.with_login_id("1001".to_string())
.check_permission("user:delete")
.await
})
.await;
assert!(
matches!(result, Err(GarrisonError::NotPermission(ref perm)) if perm == "user:delete"),
"未持有权限应返回 NotPermission,实际: {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_permission_with_token_succeeds() {
let mut perms = HashMap::new();
perms.insert("1001".to_string(), vec!["user:read".to_string()]);
init_manager_with_perms(false, perms, HashMap::new()).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let result = with_default_tenant(async {
ParameterQueryBuilder::new()
.with_token(&token)
.check_permission("user:read")
.await
})
.await;
assert!(
result.is_ok(),
"token 上下文持有权限应返回 Ok,实际: {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_permission_with_token_returns_not_permission_when_denied() {
let perms: HashMap<String, Vec<String>> = HashMap::new();
init_manager_with_perms(false, perms, HashMap::new()).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let result = with_default_tenant(async {
ParameterQueryBuilder::new()
.with_token(&token)
.check_permission("user:delete")
.await
})
.await;
assert!(
matches!(result, Err(GarrisonError::NotPermission(_))),
"token 上下文未持有权限应返回 NotPermission,实际: {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_role_without_context_returns_internal() {
GarrisonManager::reset_for_test();
let builder = ParameterQueryBuilder::new();
let result = builder.check_role("admin").await;
assert!(
matches!(result, Err(GarrisonError::Internal(ref msg)) if msg.contains("stp-param-login-id-missing")),
"未设置上下文时 check_role 应返回 Internal 错误,实际: {:?}",
result
);
}
#[tokio::test]
#[serial]
async fn check_role_with_login_id_succeeds_when_authorized() {
let mut roles = HashMap::new();
roles.insert("1001".to_string(), vec!["admin".to_string()]);
init_manager_with_perms(false, HashMap::new(), roles).await;
let result = with_default_tenant(async {
ParameterQueryBuilder::new()
.with_login_id("1001".to_string())
.check_role("admin")
.await
})
.await;
assert!(result.is_ok(), "持有角色应返回 Ok,实际: {:?}", result);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_role_with_login_id_returns_not_role_when_denied() {
let roles: HashMap<String, Vec<String>> = HashMap::new();
init_manager_with_perms(false, HashMap::new(), roles).await;
let result = with_default_tenant(async {
ParameterQueryBuilder::new()
.with_login_id("1001".to_string())
.check_role("superadmin")
.await
})
.await;
assert!(
matches!(result, Err(GarrisonError::NotRole(ref role)) if role == "superadmin"),
"未持有角色应返回 NotRole,实际: {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_role_with_token_succeeds() {
let mut roles = HashMap::new();
roles.insert("1001".to_string(), vec!["admin".to_string()]);
init_manager_with_perms(false, HashMap::new(), roles).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let result = with_default_tenant(async {
ParameterQueryBuilder::new()
.with_token(&token)
.check_role("admin")
.await
})
.await;
assert!(
result.is_ok(),
"token 上下文持有角色应返回 Ok,实际: {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_role_with_token_returns_not_role_when_denied() {
let roles: HashMap<String, Vec<String>> = HashMap::new();
init_manager_with_perms(false, HashMap::new(), roles).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let result = with_default_tenant(async {
ParameterQueryBuilder::new()
.with_token(&token)
.check_role("superadmin")
.await
})
.await;
assert!(
matches!(result, Err(GarrisonError::NotRole(_))),
"token 上下文未持有角色应返回 NotRole,实际: {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn async_check_permission_works() {
let mut perms = HashMap::new();
perms.insert("2002".to_string(), vec!["user:read".to_string()]);
init_manager_with_perms(false, perms, HashMap::new()).await;
let result = with_default_tenant(async {
ParameterQueryBuilder::new()
.with_login_id("2002".to_string())
.check_permission("user:read")
.await
})
.await;
assert!(
result.is_ok(),
"async check_permission 应正常工作,实际: {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[test]
fn builder_default_equals_new() {
let default_builder = ParameterQueryBuilder::default();
let new_builder = ParameterQueryBuilder::new();
assert!(default_builder.login_id.is_none());
assert!(default_builder.device.is_none());
assert!(default_builder.token.is_none());
assert!(new_builder.login_id.is_none());
assert!(new_builder.device.is_none());
assert!(new_builder.token.is_none());
}
#[tokio::test]
async fn mock_dao_atomic_and_default_methods_coverage() {
use crate::dao::GarrisonDao;
let dao = MockDao::new();
dao.set("k1", "v1", 60).await.unwrap();
let _ = dao.set_if_absent("a1", "v1", 60).await;
let _ = dao.get_and_delete("a1").await;
let _ = dao.incr("ctr", 60).await;
let _ = dao.decr("ctr").await;
let _ = dao.rename("k1", "k2").await;
let _ = dao.compare_and_swap("k2", Some("v1"), "v2", 60).await;
let _ = dao.set_permanent("p1", "val").await;
let _ = dao.get_with_ttl("k1").await;
let _ = dao.get_timeout("k1").await;
let _ = dao.keys("*").await;
let _ = dao.find_social_binding(0, "w", "o").await;
let _ = dao.insert_social_binding(0, "u", "w", "o", None, 0).await;
let _ = dao.compare_and_update_if_greater("k1", 10, 60).await;
let _ = dao.eval_lua("r", vec![], vec![]).await;
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
{
let _ = dao.insert_credit_consumption(0, "r", 1, 1, 1, 0).await;
let _ = dao.query_credit_consumption(0, 0, 0).await;
let _ = dao.query_role_hierarchy_edges(0).await;
let _ = dao.insert_role_hierarchy_edge(0, "c", "p").await;
let _ = dao.delete_role_hierarchy_edge(0, "c", "p").await;
}
}
}