use crate::config::GarrisonConfig;
use crate::error::GarrisonResult;
use crate::session::GarrisonSession;
use crate::stp::core::GarrisonCore;
use crate::stp::mfa::MfaLogic;
use crate::stp::permission::PermissionLogic;
use crate::stp::session::SessionLogic;
use crate::stp::token::TokenLogic;
use crate::stp::LoginParams;
use std::sync::Arc;
use std::time::Duration;
use tokio::runtime::Handle;
use tokio::task;
use tokio::task::JoinHandle;
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
static CURRENT_BACKEND: std::sync::Mutex<Option<Arc<dyn crate::backend::AuthBackend>>> =
std::sync::Mutex::new(None);
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
pub fn init_backend(backend: Arc<dyn crate::backend::AuthBackend>) -> GarrisonResult<()> {
let mut guard = CURRENT_BACKEND
.lock()
.map_err(|_| crate::error::GarrisonError::Config("CURRENT_BACKEND lock poisoned".into()))?;
if guard.is_some() {
return Err(crate::error::GarrisonError::Config(
"Backend already initialized".into(),
));
}
*guard = Some(backend);
Ok(())
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
fn get_backend() -> GarrisonResult<Option<Arc<dyn crate::backend::AuthBackend>>> {
let guard = CURRENT_BACKEND
.lock()
.map_err(|_| crate::error::GarrisonError::Config("CURRENT_BACKEND lock poisoned".into()))?;
if let Some(backend) = guard.as_ref() {
return Ok(Some(backend.clone()));
}
#[cfg(not(feature = "backend-embedded"))]
{
Err(crate::error::GarrisonError::Config(
"Backend not initialized. Call init_backend() first.".into(),
))
}
#[cfg(feature = "backend-embedded")]
{
Ok(None)
}
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
#[cfg(test)]
pub(crate) fn reset_backend_for_test() {
if let Ok(mut guard) = CURRENT_BACKEND.lock() {
*guard = None;
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum JwtMode {
Stateless,
#[default]
Mixin,
Simple,
}
pub struct GarrisonUtil;
impl GarrisonUtil {
pub async fn login(id: impl Into<String>, params: &LoginParams) -> GarrisonResult<String> {
let id: String = id.into();
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
return backend.login(&id, params).await;
}
}
crate::manager::GarrisonManager::logic()?
.login(&id, params)
.await
}
pub async fn login_simple(id: impl Into<String>) -> GarrisonResult<String> {
Self::login(id, &LoginParams::default()).await
}
pub async fn logout() -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
return backend.logout(&token).await;
}
}
crate::manager::GarrisonManager::logic()?.logout().await
}
pub async fn logout_by_login_id(login_id: impl Into<String>) -> GarrisonResult<()> {
let login_id: String = login_id.into();
crate::manager::GarrisonManager::logic()?
.logout_by_login_id(&login_id)
.await
}
pub async fn kickout(login_id: impl Into<String>) -> GarrisonResult<()> {
let login_id: String = login_id.into();
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
return backend.kickout(&login_id).await;
}
}
crate::manager::GarrisonManager::logic()?
.kickout(&login_id)
.await
}
pub async fn kickout_by_token(token: &str) -> GarrisonResult<()> {
crate::manager::GarrisonManager::logic()?
.kickout_by_token(token)
.await
}
pub async fn revoke_token(token: &str) -> GarrisonResult<()> {
crate::manager::GarrisonManager::logic()?
.revoke_token(token)
.await
}
pub async fn check_login() -> GarrisonResult<bool> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
return backend.check_login(&token).await;
}
}
crate::manager::GarrisonManager::logic()?
.check_login()
.await
}
pub async fn get_login_id() -> GarrisonResult<Option<String>> {
crate::manager::GarrisonManager::logic()?
.get_login_id()
.await
}
pub async fn get_login_id_by_token(token: &str) -> GarrisonResult<Option<String>> {
super::with_current_token(token.to_string(), async { Self::get_login_id().await }).await
}
pub async fn check_permission(permission: &str) -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
return backend.check_permission(&token, permission).await;
}
}
crate::manager::GarrisonManager::logic()?
.check_permission(permission)
.await
}
pub async fn check_role(role: &str) -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
return backend.check_role(&token, role).await;
}
}
crate::manager::GarrisonManager::logic()?
.check_role(role)
.await
}
pub async fn has_permission(permission: &str) -> GarrisonResult<bool> {
if permission.is_empty() {
return Err(crate::error::GarrisonError::InvalidParam(
"permission 不能为空".to_string(),
));
}
crate::manager::GarrisonManager::logic()?
.has_permission(permission)
.await
}
pub async fn has_role(role: &str) -> GarrisonResult<bool> {
if role.is_empty() {
return Err(crate::error::GarrisonError::InvalidParam(
"role 不能为空".to_string(),
));
}
crate::manager::GarrisonManager::logic()?
.has_role(role)
.await
}
pub async fn get_permission_list() -> GarrisonResult<Vec<String>> {
crate::manager::GarrisonManager::logic()?
.get_permission_list()
.await
}
pub async fn get_role_list() -> GarrisonResult<Vec<String>> {
crate::manager::GarrisonManager::logic()?
.get_role_list()
.await
}
pub async fn check_access_token() -> GarrisonResult<()> {
crate::manager::GarrisonManager::logic()?
.check_access_token()
.await
}
pub async fn check_client_token() -> GarrisonResult<()> {
crate::manager::GarrisonManager::logic()?
.check_client_token()
.await
}
pub async fn check_temp_token() -> GarrisonResult<()> {
crate::manager::GarrisonManager::logic()?
.check_temp_token()
.await
}
pub async fn check_safe() -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
let is_safe = backend.check_safe(&token).await?;
if is_safe {
return Ok(());
}
return Err(crate::error::GarrisonError::NotSafe {
reason: "二级认证未通过".to_string(),
});
}
}
crate::manager::GarrisonManager::logic()?.check_safe().await
}
pub async fn check_disable() -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
let is_disabled = backend.check_disable(&token).await?;
if is_disabled {
return Err(crate::error::GarrisonError::DisableService {
service: "default".to_string(),
until: None,
});
}
return Ok(());
}
}
crate::manager::GarrisonManager::logic()?
.check_disable()
.await
}
pub async fn check_api_key(namespace: &str) -> GarrisonResult<()> {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
{
if let Some(backend) = get_backend()? {
let token = super::current_token()?;
return backend.check_api_key(&token, namespace).await;
}
}
crate::manager::GarrisonManager::logic()?
.check_api_key(namespace)
.await
}
pub async fn login_by_token(token: &str) -> GarrisonResult<()> {
crate::manager::GarrisonManager::logic()?
.login_by_token(token)
.await
}
pub async fn verify_token(token: &str) -> GarrisonResult<String> {
crate::manager::GarrisonManager::logic()?
.verify_token(token)
.await
}
pub async fn refresh_token(token: &str) -> GarrisonResult<String> {
crate::manager::GarrisonManager::logic()?
.refresh_token(token)
.await
}
pub fn check_login_sync() -> GarrisonResult<bool> {
task::block_in_place(|| Handle::current().block_on(Self::check_login()))
}
pub fn check_permission_sync(perm: &str) -> GarrisonResult<()> {
let perm = perm.to_string();
task::block_in_place(|| Handle::current().block_on(Self::check_permission(&perm)))
}
pub fn check_role_sync(role: &str) -> GarrisonResult<()> {
let role = role.to_string();
task::block_in_place(|| Handle::current().block_on(Self::check_role(&role)))
}
pub fn check_access_token_sync() -> GarrisonResult<()> {
task::block_in_place(|| Handle::current().block_on(Self::check_access_token()))
}
pub fn check_client_token_sync() -> GarrisonResult<()> {
task::block_in_place(|| Handle::current().block_on(Self::check_client_token()))
}
pub fn check_temp_token_sync() -> GarrisonResult<()> {
task::block_in_place(|| Handle::current().block_on(Self::check_temp_token()))
}
pub fn check_api_key_sync(namespace: &str) -> GarrisonResult<()> {
let namespace = namespace.to_string();
task::block_in_place(|| Handle::current().block_on(Self::check_api_key(&namespace)))
}
pub fn check_safe_sync() -> GarrisonResult<()> {
task::block_in_place(|| Handle::current().block_on(Self::check_safe()))
}
pub fn check_disable_sync() -> GarrisonResult<()> {
task::block_in_place(|| Handle::current().block_on(Self::check_disable()))
}
pub fn config() -> GarrisonResult<Arc<GarrisonConfig>> {
Ok(crate::manager::GarrisonManager::logic()?.config())
}
}
pub fn spawn_cleanup_task(
session: Arc<GarrisonSession>,
interval_secs: i64,
) -> Option<JoinHandle<()>> {
if interval_secs <= 0 {
return None;
}
let interval_duration = Duration::from_secs(interval_secs as u64);
let handle = tokio::spawn(async move {
let mut interval = tokio::time::interval(interval_duration);
loop {
interval.tick().await;
if let Err(e) = session.cleanup_expired_tokens().await {
tracing::warn!("cleanup_expired_tokens failed: {}", e);
}
}
});
Some(handle)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::tests::MockDao;
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use async_trait::async_trait;
use std::sync::atomic::{AtomicUsize, Ordering};
fn make_session(timeout: u64, active_timeout: u64) -> (Arc<MockDao>, Arc<GarrisonSession>) {
let dao = Arc::new(MockDao::new());
let session = Arc::new(GarrisonSession::new(dao.clone(), timeout, active_timeout));
(dao, session)
}
#[tokio::test]
async fn spawn_cleanup_task_negative_interval_returns_none() {
let (_dao, session) = make_session(3600, 86400);
let handle = spawn_cleanup_task(session, -1);
assert!(handle.is_none(), "interval=-1 应返回 None");
let (_dao, session) = make_session(3600, 86400);
let handle = spawn_cleanup_task(session, 0);
assert!(handle.is_none(), "interval=0 应返回 None");
}
#[tokio::test]
async fn spawn_cleanup_task_positive_interval_starts_and_cleans() {
let (_dao, session) = make_session(1, 86400);
session.create("1001", "T1").await.unwrap();
assert!(
session.get_token_by_login_id("1001").is_some(),
"清理前 token 应存在于 login_token_map"
);
let handle = spawn_cleanup_task(session.clone(), 1);
assert!(handle.is_some(), "interval=1 应返回 Some");
tokio::time::sleep(Duration::from_secs(3)).await;
assert!(
session.get_token_by_login_id("1001").is_none(),
"清理后 token 应从 login_token_map 移除"
);
if let Some(h) = handle {
h.abort();
}
}
#[tokio::test]
async fn spawn_cleanup_task_can_be_cancelled() {
let (_dao, session) = make_session(3600, 86400);
let handle = spawn_cleanup_task(session, 1).unwrap();
tokio::time::sleep(Duration::from_millis(100)).await;
handle.abort();
let result = handle.await;
assert!(
result.is_err(),
"abort 后 await 应返回 Err,实际: {:?}",
result
);
assert!(
result.unwrap_err().is_cancelled(),
"JoinError 应为 cancelled"
);
}
struct FailingGetDao {
get_call_count: Arc<AtomicUsize>,
}
#[async_trait]
impl GarrisonDao for FailingGetDao {
async fn get(&self, _key: &str) -> GarrisonResult<Option<String>> {
self.get_call_count.fetch_add(1, Ordering::SeqCst);
Err(GarrisonError::Dao("模拟清理失败".to_string()))
}
async fn set(&self, _key: &str, _value: &str, _ttl_seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn update(&self, _key: &str, _value: &str) -> GarrisonResult<()> {
Ok(())
}
async fn expire(&self, _key: &str, _seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn delete(&self, _key: &str) -> GarrisonResult<()> {
Ok(())
}
}
#[tokio::test]
async fn spawn_cleanup_task_cleanup_failure_does_not_crash() {
let get_call_count = Arc::new(AtomicUsize::new(0));
let dao: Arc<dyn GarrisonDao> = Arc::new(FailingGetDao {
get_call_count: get_call_count.clone(),
});
let session = Arc::new(GarrisonSession::new(dao, 3600, 86400));
session.add_login_token("user1", "token1");
let handle = spawn_cleanup_task(session.clone(), 1).unwrap();
tokio::time::sleep(Duration::from_millis(1500)).await;
let calls = get_call_count.load(Ordering::SeqCst);
assert!(
calls >= 2,
"清理失败后 task 应继续运行,至少调用 2 次 get,实际: {}",
calls
);
assert!(!handle.is_finished(), "清理失败不应导致 task 终止");
handle.abort();
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
struct MockAuthBackend {
check_login_calls: Arc<AtomicUsize>,
check_permission_calls: Arc<AtomicUsize>,
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
impl MockAuthBackend {
fn new() -> Self {
Self {
check_login_calls: Arc::new(AtomicUsize::new(0)),
check_permission_calls: Arc::new(AtomicUsize::new(0)),
}
}
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
#[async_trait::async_trait]
impl crate::backend::AuthBackend for MockAuthBackend {
async fn login(&self, _login_id: &str, _params: &LoginParams) -> GarrisonResult<String> {
Ok("mock-token".to_string())
}
async fn logout(&self, _token: &str) -> GarrisonResult<()> {
Ok(())
}
async fn check_login(&self, _token: &str) -> GarrisonResult<bool> {
self.check_login_calls.fetch_add(1, Ordering::SeqCst);
Ok(true)
}
async fn check_permission(&self, _token: &str, _permission: &str) -> GarrisonResult<()> {
self.check_permission_calls.fetch_add(1, Ordering::SeqCst);
Ok(())
}
async fn check_role(&self, _token: &str, _role: &str) -> GarrisonResult<()> {
Ok(())
}
async fn check_safe(&self, _token: &str) -> GarrisonResult<bool> {
Ok(true)
}
async fn check_disable(&self, _token: &str) -> GarrisonResult<bool> {
Ok(false)
}
async fn check_api_key(&self, _api_key: &str, _namespace: &str) -> GarrisonResult<()> {
Ok(())
}
async fn get_token_info(&self, token: &str) -> GarrisonResult<crate::backend::TokenInfo> {
Ok(crate::backend::TokenInfo {
token: token.to_string(),
created_at: 0,
last_active_at: 0,
})
}
async fn get_session(&self, token: &str) -> GarrisonResult<crate::backend::SessionData> {
Ok(crate::backend::SessionData {
token: token.to_string(),
login_id: "mock-user".to_string(),
created_at: 0,
last_active_at: 0,
attrs: std::collections::HashMap::new(),
device: None,
ip: None,
user_agent: None,
safe_services: std::collections::HashMap::new(),
#[cfg(feature = "dynamic-active-timeout")]
dynamic_active_timeout: None,
#[cfg(feature = "anonymous-session")]
is_anon: false,
})
}
async fn kickout(&self, _login_id: &str) -> GarrisonResult<()> {
Ok(())
}
async fn switch_to(&self, _token: &str, _target_login_id: &str) -> GarrisonResult<()> {
Ok(())
}
async fn renew_to_equivalent(&self, token: &str) -> GarrisonResult<String> {
Ok(format!("renewed-{}", token))
}
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
#[tokio::test]
#[serial_test::serial]
async fn t114_init_backend_success() {
reset_backend_for_test();
let backend = Arc::new(MockAuthBackend::new());
let result = init_backend(backend);
assert!(result.is_ok(), "init_backend 应成功");
reset_backend_for_test();
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
#[tokio::test]
#[serial_test::serial]
async fn t114_init_backend_duplicate_fails() {
reset_backend_for_test();
let backend1 = Arc::new(MockAuthBackend::new());
let backend2 = Arc::new(MockAuthBackend::new());
init_backend(backend1).unwrap();
let result = init_backend(backend2);
assert!(result.is_err(), "重复 init_backend 应返回错误");
reset_backend_for_test();
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
#[tokio::test]
#[serial_test::serial]
async fn t114_check_login_delegates_to_backend() {
reset_backend_for_test();
let mock = MockAuthBackend::new();
let call_count = mock.check_login_calls.clone();
init_backend(Arc::new(mock)).unwrap();
let result = crate::stp::with_current_token("test-token".to_string(), async {
GarrisonUtil::check_login().await
})
.await;
assert!(result.is_ok(), "check_login 应成功");
assert!(result.unwrap(), "MockAuthBackend.check_login 返回 true");
assert_eq!(
call_count.load(Ordering::SeqCst),
1,
"MockAuthBackend.check_login 应被调用 1 次"
);
reset_backend_for_test();
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
#[tokio::test]
#[serial_test::serial]
async fn t114_check_permission_delegates_to_backend() {
reset_backend_for_test();
let mock = MockAuthBackend::new();
let call_count = mock.check_permission_calls.clone();
init_backend(Arc::new(mock)).unwrap();
let result = crate::stp::with_current_token("test-token".to_string(), async {
GarrisonUtil::check_permission("user:read").await
})
.await;
assert!(result.is_ok(), "check_permission 应成功");
assert_eq!(
call_count.load(Ordering::SeqCst),
1,
"MockAuthBackend.check_permission 应被调用 1 次"
);
reset_backend_for_test();
}
#[cfg(feature = "backend-embedded")]
#[tokio::test]
#[serial_test::serial]
async fn t114_fallback_to_garrison_manager_when_not_initialized() {
reset_backend_for_test();
let result = crate::stp::with_current_token("test-token".to_string(), async {
GarrisonUtil::check_login().await
})
.await;
assert!(
result.is_err(),
"未初始化时应 fallback 到 GarrisonManager 并返回其错误"
);
reset_backend_for_test();
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
#[tokio::test]
#[serial_test::serial]
async fn t114_check_safe_true_returns_ok() {
reset_backend_for_test();
init_backend(Arc::new(MockAuthBackend::new())).unwrap();
let result = crate::stp::with_current_token("test-token".to_string(), async {
GarrisonUtil::check_safe().await
})
.await;
assert!(result.is_ok(), "check_safe=true 应返回 Ok(())");
reset_backend_for_test();
}
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
#[tokio::test]
#[serial_test::serial]
async fn t114_check_disable_false_returns_ok() {
reset_backend_for_test();
init_backend(Arc::new(MockAuthBackend::new())).unwrap();
let result = crate::stp::with_current_token("test-token".to_string(), async {
GarrisonUtil::check_disable().await
})
.await;
assert!(result.is_ok(), "check_disable=false 应返回 Ok(())");
reset_backend_for_test();
}
#[cfg(feature = "backend-embedded")]
#[tokio::test]
#[serial_test::serial]
async fn t116_embedded_mode_delegates_to_garrison_manager() {
reset_backend_for_test();
init_backend(Arc::new(crate::backend::BackendEmbedded::new())).unwrap();
let result = crate::stp::with_current_token("test-token".to_string(), async {
GarrisonUtil::check_login().await
})
.await;
assert!(
result.is_err(),
"Embedded 模式应委托 BackendEmbedded → GarrisonManager,未初始化时返回错误"
);
reset_backend_for_test();
}
#[cfg(feature = "backend-embedded")]
#[tokio::test]
#[serial_test::serial]
async fn t116_embedded_mode_fallback_and_delegate_consistent() {
reset_backend_for_test();
let fallback_result = crate::stp::with_current_token("test-token".to_string(), async {
GarrisonUtil::check_login().await
})
.await;
init_backend(Arc::new(crate::backend::BackendEmbedded::new())).unwrap();
let delegate_result = crate::stp::with_current_token("test-token".to_string(), async {
GarrisonUtil::check_login().await
})
.await;
assert!(fallback_result.is_err(), "fallback 路径应返回错误");
assert!(delegate_result.is_err(), "委托路径应返回错误");
match (fallback_result.unwrap_err(), delegate_result.unwrap_err()) {
(crate::error::GarrisonError::Session(_), crate::error::GarrisonError::Session(_)) => {
},
(f, d) => panic!(
"两条路径错误类型应一致(Session),fallback={:?}, delegate={:?}",
f, d
),
}
reset_backend_for_test();
}
#[cfg(feature = "backend-remote")]
#[tokio::test]
#[serial_test::serial]
async fn t117_remote_mode_delegates_to_backend_remote() {
use wiremock::matchers::{header, method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
reset_backend_for_test();
let server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/check-login"))
.and(header("X-API-Key", "test-api-key"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": true,
"error_code": null,
"message": null
})))
.expect(1)
.mount(&server)
.await;
let remote = crate::backend::BackendRemote::new(
server.uri(),
"test-api-key",
std::time::Duration::from_secs(5),
)
.unwrap();
init_backend(Arc::new(remote)).unwrap();
let result = crate::stp::with_current_token("test-token".to_string(), async {
GarrisonUtil::check_login().await
})
.await;
assert!(
result.is_ok(),
"Remote 模式 check_login 应成功: {:?}",
result
);
assert!(
result.unwrap(),
"mock server 返回 true,GarrisonUtil::check_login 应返回 true"
);
reset_backend_for_test();
}
#[cfg(feature = "backend-remote")]
#[tokio::test]
#[serial_test::serial]
async fn t117_remote_mode_check_permission_delegates() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
reset_backend_for_test();
let server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/api/v1/auth/check-permission"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"data": null,
"error_code": null,
"message": null
})))
.expect(1)
.mount(&server)
.await;
let remote = crate::backend::BackendRemote::new(
server.uri(),
"test-api-key",
std::time::Duration::from_secs(5),
)
.unwrap();
init_backend(Arc::new(remote)).unwrap();
let result = crate::stp::with_current_token("test-token".to_string(), async {
GarrisonUtil::check_permission("user:read").await
})
.await;
assert!(
result.is_ok(),
"Remote 模式 check_permission 应成功: {:?}",
result
);
reset_backend_for_test();
}
#[test]
fn jwt_mode_default_is_mixin() {
let mode = JwtMode::default();
assert_eq!(
mode,
JwtMode::Mixin,
"JwtMode 默认应为 Mixin(推荐平衡模式)"
);
}
#[test]
fn jwt_mode_variants_distinct() {
assert_ne!(JwtMode::Stateless, JwtMode::Mixin);
assert_ne!(JwtMode::Mixin, JwtMode::Simple);
assert_ne!(JwtMode::Stateless, JwtMode::Simple);
assert_eq!(JwtMode::Stateless, JwtMode::Stateless);
assert_eq!(JwtMode::Mixin, JwtMode::Mixin);
assert_eq!(JwtMode::Simple, JwtMode::Simple);
}
#[test]
fn jwt_mode_clone_preserves_value() {
let original = JwtMode::Stateless;
let cloned = original;
assert_eq!(original, cloned);
assert_eq!(JwtMode::Mixin.clone(), JwtMode::Mixin);
}
#[tokio::test]
async fn has_permission_empty_returns_invalid_param() {
let result = GarrisonUtil::has_permission("").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::InvalidParam(_))),
"空 permission 应返回 InvalidParam,实际: {:?}",
result
);
}
#[tokio::test]
async fn has_role_empty_returns_invalid_param() {
let result = GarrisonUtil::has_role("").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::InvalidParam(_))),
"空 role 应返回 InvalidParam,实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn login_simple_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::login_simple("user1").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn logout_by_login_id_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::logout_by_login_id("user1").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn kickout_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::kickout("user1").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn config_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::config();
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn get_login_id_by_token_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::get_login_id_by_token("some-token").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn login_with_params_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::login("user1", &LoginParams::default()).await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn logout_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::logout().await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn kickout_by_token_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::kickout_by_token("some-token").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn revoke_token_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::revoke_token("some-token").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn check_login_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_login().await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn get_login_id_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::get_login_id().await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn check_permission_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_permission("user:read").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn check_role_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_role("admin").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn has_permission_non_empty_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::has_permission("user:read").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn has_role_non_empty_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::has_role("admin").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn get_permission_list_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::get_permission_list().await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn get_role_list_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::get_role_list().await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn check_access_token_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_access_token().await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn check_client_token_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_client_token().await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn check_temp_token_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_temp_token().await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn check_safe_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_safe().await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn check_disable_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_disable().await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn check_api_key_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_api_key("default").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn login_by_token_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::login_by_token("external-token").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn verify_token_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::verify_token("some-token").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn refresh_token_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::refresh_token("old-token").await;
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn check_login_sync_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_login_sync();
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn check_permission_sync_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_permission_sync("user:read");
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn check_role_sync_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_role_sync("admin");
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn check_access_token_sync_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_access_token_sync();
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn check_client_token_sync_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_client_token_sync();
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn check_temp_token_sync_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_temp_token_sync();
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn check_api_key_sync_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_api_key_sync("default");
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn check_safe_sync_delegates_to_garrison_manager() {
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
reset_backend_for_test();
crate::manager::GarrisonManager::reset_for_test();
let result = GarrisonUtil::check_safe_sync();
assert!(
matches!(result, Err(crate::error::GarrisonError::Session(ref msg)) if msg.contains("manager-not-init")),
"未初始化时应返回 'GarrisonManager 未初始化',实际: {:?}",
result
);
}
}