mod suite {
use crate::dao::tests::MockDao;
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use crate::session::GarrisonSession;
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
use crate::stp::util::{init_backend, reset_backend_for_test};
use crate::stp::util::{spawn_cleanup_task, GarrisonUtil, JwtMode};
use crate::stp::LoginParams;
use async_trait::async_trait;
use serial_test::serial;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::time::Duration;
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,
0,
));
(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(())
}
crate::atomic_test_fallback!();
}
#[tokio::test]
async fn spawn_cleanup_task_cleanup_failure_does_not_crash() {
let get_call_count = Arc::new(AtomicUsize::new(0));
{
let d = FailingGetDao {
get_call_count: Arc::new(AtomicUsize::new(0)),
};
let _ = d.set_if_absent("a", "v", 60).await;
let _ = d.get_and_delete("a").await;
let _ = d.incr("c", 60).await;
let _ = d.decr("c").await;
let _ = d.rename("a", "b").await;
let _ = d.compare_and_swap("b", None, "v", 60).await;
let _ = d.set_permanent("p", "v").await;
let _ = d.get_timeout("k").await;
let _ = d.get_with_ttl("k").await;
let _ = d.find_social_binding(0, "w", "o").await;
let _ = d.insert_social_binding(0, "u", "w", "o", None, 0).await;
let _ = d.compare_and_update_if_greater("k", 1, 60).await;
let _ = d.eval_lua("r", vec![], vec![]).await;
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
{
let _ = d.insert_credit_consumption(0, "r", 1, 1, 1, 0).await;
let _ = d.query_credit_consumption(0, 0, 0).await;
let _ = d.query_role_hierarchy_edges(0).await;
let _ = d.insert_role_hierarchy_edge(0, "c", "p").await;
let _ = d.delete_role_hierarchy_edge(0, "c", "p").await;
}
}
let dao: Arc<dyn GarrisonDao> = Arc::new(FailingGetDao {
get_call_count: get_call_count.clone(),
});
let session = Arc::new(GarrisonSession::new(dao, 3600, 86400, 0));
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 = "session-extra")]
dynamic_active_timeout: None,
#[cfg(feature = "session-extra")]
is_anon: false,
effective_timeout: None,
amr_ledger: Vec::new(),
auth_time: None,
})
}
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();
crate::manager::GarrisonManager::reset_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();
crate::manager::GarrisonManager::reset_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();
}
#[serial]
#[test]
fn jwt_mode_default_is_mixin() {
let mode = JwtMode::default();
assert_eq!(
mode,
JwtMode::Mixin,
"JwtMode 默认应为 Mixin(推荐平衡模式)"
);
}
#[serial]
#[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);
}
#[serial]
#[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);
}
#[serial]
#[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
);
}
#[serial]
#[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
);
}
}