use super::mock::MockInterface;
use super::*;
use crate::config::GarrisonConfig;
use crate::context::tenant::with_default_tenant;
use crate::dao::tests::MockDao;
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use crate::session::GarrisonSession;
use crate::stp::util::spawn_cleanup_task;
use crate::stp::{GarrisonInterface, GarrisonUtil, LoginParams, SessionLogic};
use crate::strategy::{GarrisonPermissionStrategy, GarrisonPermissionStrategyDefault};
use async_trait::async_trait;
use serial_test::serial;
fn make_config() -> GarrisonConfig {
let mut config = GarrisonConfig::default_config();
config.timeout = 3600;
config.active_timeout = -1;
config.throw_on_not_login = false;
config
}
async fn with_token<R>(token: String, f: impl std::future::Future<Output = R>) -> R {
crate::stp::with_current_token(token, f).await
}
#[test]
#[serial]
fn logic_returns_error_when_not_initialized() {
GarrisonManager::reset_for_test();
let result = GarrisonManager::logic();
assert!(result.is_err());
match result {
Err(GarrisonError::Session(ref msg)) if msg.contains("manager-not-init") => {},
other => panic!("应返回 manager-not-init,实际: {:?}", other.map(|_| ())),
}
}
#[test]
#[serial]
fn is_initialized_returns_false_when_not_initialized() {
GarrisonManager::reset_for_test();
assert!(!GarrisonManager::is_initialized());
}
#[tokio::test]
#[serial]
async fn init_sets_initialized_flag() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
let result = GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await;
assert!(result.is_ok(), "init 应成功: {:?}", result.map(|_| ()));
assert!(GarrisonManager::is_initialized());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn init_rejects_invalid_config() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let mut config = GarrisonConfig::default_config();
config.timeout = 0; let config = Arc::new(config);
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
let result = GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
GarrisonError::Config(ref msg) if msg.contains("config-timeout-must-positive")
));
assert!(!GarrisonManager::is_initialized());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn init_handles_negative_active_timeout() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config()); let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
let result = GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await;
assert!(result.is_ok(), "active_timeout=-1 应使用 timeout 兜底");
assert!(GarrisonManager::is_initialized());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn end_to_end_login_check_logout() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
assert!(GarrisonManager::is_initialized());
let token = GarrisonUtil::login_simple("1001").await.unwrap();
assert!(!token.is_empty());
let is_logged_in = with_token(token.clone(), async { GarrisonUtil::check_login().await })
.await
.unwrap();
assert!(is_logged_in, "登录后 check_login 应返回 true");
let logout_result = with_token(token.clone(), async { GarrisonUtil::logout().await }).await;
assert!(
logout_result.is_ok(),
"logout 应成功: {:?}",
logout_result.map(|_| ())
);
let is_still_logged_in = with_token(token.clone(), async { GarrisonUtil::check_login().await })
.await
.unwrap();
assert!(!is_still_logged_in, "logout 后 check_login 应返回 false");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn end_to_end_check_permission() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> =
Arc::new(MockInterface::new().with_permission("1001", &["user:read", "user:write"]));
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let check_result = with_token(token.clone(), async {
with_default_tenant(async { GarrisonUtil::check_permission("user:read").await }).await
})
.await;
assert!(
check_result.is_ok(),
"持有权限应通过: {:?}",
check_result.map(|_| ())
);
let check_result = with_token(token.clone(), async {
with_default_tenant(async { GarrisonUtil::check_permission("user:delete").await }).await
})
.await;
assert!(check_result.is_err());
assert!(matches!(
check_result.unwrap_err(),
GarrisonError::NotPermission(ref p) if p == "user:delete"
));
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn end_to_end_check_role() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> =
Arc::new(MockInterface::new().with_role("1001", &["admin"]));
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let check_result = with_token(
token.clone(),
with_default_tenant(async { GarrisonUtil::check_role("admin").await }),
)
.await;
assert!(
check_result.is_ok(),
"持有角色应通过: {:?}",
check_result.map(|_| ())
);
let check_result = with_token(
token.clone(),
with_default_tenant(async { GarrisonUtil::check_role("superadmin").await }),
)
.await;
assert!(check_result.is_err());
assert!(matches!(
check_result.unwrap_err(),
GarrisonError::NotRole(ref r) if r == "superadmin"
));
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn util_login_fails_when_not_initialized() {
GarrisonManager::reset_for_test();
let result = GarrisonUtil::login_simple("1001").await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
GarrisonError::Session(ref msg) if msg.contains("manager-not-init")
));
}
#[tokio::test]
#[serial]
async fn init_overwrites_existing() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao.clone())
.config(config.clone())
.interface(interface.clone())
.build()
.await
.unwrap();
assert!(GarrisonManager::is_initialized());
let result = GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await;
assert!(
result.is_ok(),
"重复 init 应覆盖式更新: {:?}",
result.map(|_| ())
);
assert!(GarrisonManager::is_initialized());
GarrisonManager::reset_for_test();
}
#[serial]
#[test]
fn default_factory_registered_via_inventory() {
use std::iter::Iterator;
let found = inventory::iter::<GarrisonLogicFactoryEntry>()
.filter(|e| e.name == "default")
.count();
assert!(
found >= 1,
"应至少注册一个 name='default' 的 factory,实际: {}",
found
);
}
#[serial]
#[tokio::test]
async fn default_factory_builds_working_logic() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
let timeout = u64::try_from(config.timeout).unwrap();
let session = Arc::new(GarrisonSession::new(dao, timeout, timeout, 0));
let firewall: Arc<dyn GarrisonPermissionStrategy> =
Arc::new(GarrisonPermissionStrategyDefault::new(interface));
#[cfg(feature = "listener")]
let ctx = GarrisonLogicFactoryContext {
plugin_manager: None,
listener_manager: None,
auth_logic: None,
permission_checker: None,
disable_repository: None,
#[cfg(feature = "three-tier-cache")]
user_cache_service: None,
};
#[cfg(not(feature = "listener"))]
let ctx = GarrisonLogicFactoryContext {
plugin_manager: None,
auth_logic: None,
permission_checker: None,
disable_repository: None,
#[cfg(feature = "three-tier-cache")]
user_cache_service: None,
};
let logic = garrison_logic_factory_default(session, config, firewall, &ctx).unwrap();
let token = logic.login("1001", &LoginParams::default()).await.unwrap();
assert!(!token.is_empty());
}
#[tokio::test]
#[serial]
async fn init_with_positive_active_timeout() {
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 = 1800; let config = Arc::new(config);
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
let result = GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await;
assert!(
result.is_ok(),
"active_timeout=1800 应走 else 分支并成功: {:?}",
result.map(|_| ())
);
assert!(GarrisonManager::is_initialized());
let token = GarrisonUtil::login_simple("1001").await.unwrap();
assert!(!token.is_empty());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn init_with_zero_active_timeout() {
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 = 0; let config = Arc::new(config);
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
let result = GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await;
assert!(result.is_ok(), "active_timeout=0 应走 else 分支并成功");
assert!(GarrisonManager::is_initialized());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn init_rejects_invalid_token_style() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let mut config = GarrisonConfig::default_config();
config.token_style = "unknown_style".to_string(); let config = Arc::new(config);
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
let result = GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await;
assert!(result.is_err());
assert!(
matches!(result.unwrap_err(), GarrisonError::Config(ref msg) if msg.contains("config-unknown-token-style")),
"应返回 'config-unknown-token-style' 错误"
);
assert!(!GarrisonManager::is_initialized());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn builder_build_succeeds_and_login_works() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
let result = GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await;
assert!(
result.is_ok(),
"builder 构建应成功: {:?}",
result.map(|_| ())
);
assert!(GarrisonManager::is_initialized());
let token = GarrisonUtil::login_simple("1001").await.unwrap();
assert!(!token.is_empty());
GarrisonManager::reset_for_test();
}
#[tokio::test]
async fn mock_dao_expire_and_delete_work() {
let dao = MockDao::new();
dao.set("key1", "value1", 3600).await.unwrap();
dao.expire("key1", 7200).await.unwrap();
let got = dao.get("key1").await.unwrap();
assert_eq!(got, Some("value1".to_string()));
let result = dao.expire("missing", 3600).await;
assert!(
matches!(result, Err(GarrisonError::Dao(ref msg)) if msg.contains("dao-key-missing")),
"expire 不存在的键应返回 Dao(dao-key-missing),实际: {:?}",
result
);
dao.delete("key1").await.unwrap();
let got = dao.get("key1").await.unwrap();
assert!(got.is_none());
}
#[tokio::test]
#[serial]
async fn strategy_returns_error_when_not_initialized() {
GarrisonManager::reset_for_test();
let result = GarrisonManager::strategy();
match result {
Err(GarrisonError::Session(ref msg)) if msg.contains("manager-not-init") => {},
other => panic!("应返回 manager-not-init,实际: {:?}", other.map(|_| ())),
}
}
#[tokio::test]
#[serial]
async fn strategy_available_after_init() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
let strategy = GarrisonManager::strategy();
assert!(strategy.is_ok(), "init 后应能获取 strategy");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn singleton_arc_identity_preserved() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
let a = GarrisonManager::logic().unwrap();
let b = GarrisonManager::logic().unwrap();
assert!(Arc::ptr_eq(&a, &b), "logic() 应返回同一 Arc 实例");
let sa = GarrisonManager::strategy().unwrap();
let sb = GarrisonManager::strategy().unwrap();
assert!(Arc::ptr_eq(&sa, &sb), "strategy() 应返回同一 Arc 实例");
let logic = GarrisonManager::logic().unwrap();
let replacement = Arc::new(RwLock::new(Strategy::new(logic)));
GarrisonManager::with_strategy(replacement.clone()).unwrap();
let sc = GarrisonManager::strategy().unwrap();
assert!(!Arc::ptr_eq(&sa, &sc), "替换后应返回新 Arc 实例");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn with_strategy_replaces_registry() {
use crate::strategy::LoginHandler;
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
let logic = GarrisonManager::logic().unwrap();
let custom_strategy = Arc::new(RwLock::new(Strategy::new(logic)));
struct CustomLogin;
#[async_trait]
impl LoginHandler for CustomLogin {
async fn handle_login(&self, id: &str) -> GarrisonResult<String> {
Ok(format!("custom-{}", id))
}
}
custom_strategy
.write()
.register_login_handler(Arc::new(CustomLogin));
GarrisonManager::with_strategy(custom_strategy).unwrap();
let strategy = GarrisonManager::strategy().unwrap();
let login_handler = strategy.read().login_handler().clone();
let token = login_handler.handle_login("1001").await.unwrap();
assert_eq!(token, "custom-1001", "with_strategy 后应使用自定义策略");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn runtime_strategy_replacement_takes_effect_immediately() {
use crate::strategy::LoginHandler;
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
let strategy = GarrisonManager::strategy().unwrap();
let default_handler = strategy.read().login_handler().clone();
let default_token = default_handler.handle_login("1001").await.unwrap();
assert!(!default_token.is_empty());
struct CustomLogin;
#[async_trait]
impl LoginHandler for CustomLogin {
async fn handle_login(&self, id: &str) -> GarrisonResult<String> {
Ok(format!("runtime-{}", id))
}
}
strategy
.write()
.register_login_handler(Arc::new(CustomLogin));
let custom_handler = strategy.read().login_handler().clone();
let token = custom_handler.handle_login("1001").await.unwrap();
assert_eq!(token, "runtime-1001", "运行时替换策略后应立即生效");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn test_manager_registers_disable_repository() {
GarrisonManager::reset_for_test();
assert!(
GarrisonManager::disable_repository().is_none(),
"未 init 时 disable_repository() 应返回 None"
);
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
let repo = GarrisonManager::disable_repository();
assert!(repo.is_some(), "init 后 disable_repository() 应返回 Some");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn test_disable_then_check_disable_errors() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let repo = GarrisonManager::disable_repository().expect("init 后应返回 Some");
let until = chrono::Utc::now() + chrono::Duration::seconds(3600);
repo.disable("1001", "default", Some(until), 0, 3600)
.await
.unwrap();
let result = with_token(token, async { GarrisonUtil::check_disable().await }).await;
match result {
Err(GarrisonError::DisableService { service, .. }) => {
assert_eq!(service, "default");
},
other => panic!(
"封禁后 check_disable 应返回 Err(DisableService),实际: {:?}",
other
),
}
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn test_untie_disable_then_check_disable_ok() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
let token = GarrisonUtil::login_simple("1002").await.unwrap();
let repo = GarrisonManager::disable_repository().expect("init 后应返回 Some");
repo.disable("1002", "default", None, 0, 0).await.unwrap();
repo.untie_disable("1002", "default").await.unwrap();
let result = with_token(token, async { GarrisonUtil::check_disable().await }).await;
assert!(
result.is_ok(),
"解封后 check_disable 应返回 Ok,实际: {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn test_manager_disable_repository_persists() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
let repo1 = GarrisonManager::disable_repository().expect("init 后应返回 Some");
let repo2 = GarrisonManager::disable_repository().expect("init 后应返回 Some");
assert!(
Arc::ptr_eq(&repo1, &repo2),
"disable_repository() 多次调用应返回同一实例(Arc 指针相等)"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn manager_init_positive_interval_starts_cleanup_task() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let mut config = make_config();
config.token_map_cleanup_interval_secs = 1;
let config = Arc::new(config);
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
assert!(
GARRISON_MANAGER.cleanup_task_handle.read().is_some(),
"interval > 0 时 init 后应启动 cleanup task"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn manager_init_negative_interval_no_cleanup_task() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let mut config = make_config();
config.token_map_cleanup_interval_secs = -1;
let config = Arc::new(config);
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
assert!(
GARRISON_MANAGER.cleanup_task_handle.read().is_none(),
"interval = -1 时 init 不应启动 cleanup task"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn manager_init_cleanup_task_runs_after_init() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let mut config = make_config();
config.timeout = 1; config.active_timeout = -1;
config.token_map_cleanup_interval_secs = 1; let config = Arc::new(config);
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
let token = GarrisonUtil::login_simple("1001").await.unwrap();
assert!(!token.is_empty());
let logic = GarrisonManager::logic().unwrap();
assert!(
logic.session.get_token_by_login_id("1001").is_some(),
"清理前 token 应存在于 login_token_map"
);
let mut cleaned = false;
for _ in 0..50 {
if logic.session.get_token_by_login_id("1001").is_none() {
cleaned = true;
break;
}
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
}
assert!(
cleaned,
"清理后 token 应从 login_token_map 移除(TTL=1s + 每秒清理)"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
async fn manager_drop_cancels_cleanup_task() {
use std::sync::atomic::{AtomicUsize, Ordering};
use std::time::Duration;
struct CountingDao {
counter: Arc<AtomicUsize>,
}
#[async_trait]
impl GarrisonDao for CountingDao {
async fn get(&self, _key: &str) -> GarrisonResult<Option<String>> {
self.counter.fetch_add(1, Ordering::SeqCst);
Err(GarrisonError::Dao("test counting".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!();
}
let counter = Arc::new(AtomicUsize::new(0));
let dao: Arc<dyn GarrisonDao> = Arc::new(CountingDao {
counter: counter.clone(),
});
let session = Arc::new(GarrisonSession::new(dao, 3600, 86400, 0));
session.add_login_token("user1", "token1");
let handle = spawn_cleanup_task(session, 1).unwrap();
let manager = GarrisonManager::new();
*manager.cleanup_task_handle.write() = Some(Arc::new(handle));
tokio::time::sleep(Duration::from_millis(1500)).await;
let count_before = counter.load(Ordering::SeqCst);
assert!(
count_before >= 2,
"drop 前 cleanup task 应已运行至少 2 次,实际: {}",
count_before
);
drop(manager);
tokio::time::sleep(Duration::from_millis(1500)).await;
let count_after = counter.load(Ordering::SeqCst);
assert!(
count_after <= count_before + 1,
"drop 后 cleanup task 应已取消,计数不应显著增长。before={}, after={}",
count_before,
count_after
);
}
#[tokio::test]
async fn mock_interface_default_methods_with_type_coverage() {
let iface = MockInterface::new();
let _ = iface
.get_permission_list_with_type("u1", "default")
.await
.unwrap();
let _ = iface
.get_role_list_with_type("u1", "default")
.await
.unwrap();
}
#[tokio::test]
async fn counting_dao_atomic_and_default_methods_coverage() {
use std::sync::atomic::AtomicUsize;
struct CountingDao {
_counter: Arc<AtomicUsize>,
}
#[async_trait]
impl GarrisonDao for CountingDao {
async fn get(&self, _key: &str) -> GarrisonResult<Option<String>> {
Ok(None)
}
async fn set(&self, _key: &str, _value: &str, _ttl: 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!();
}
let dao = CountingDao {
_counter: Arc::new(AtomicUsize::new(0)),
};
let _ = dao.set_if_absent("a", "v", 60).await;
let _ = dao.get_and_delete("a").await;
let _ = dao.incr("c", 60).await;
let _ = dao.decr("c").await;
let _ = dao.rename("a", "b").await;
let _ = dao.compare_and_swap("b", Some("v"), "v2", 60).await;
let _ = dao.set_permanent("p", "v").await;
let _ = dao.get_timeout("k").await;
let _ = dao.get_with_ttl("k").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("k", 1, 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;
}
}