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::init(dao, config, interface);
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::init(dao, config, interface);
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
GarrisonError::Config(ref msg) if msg.contains("timeout must be 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::init(dao, config, interface);
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::init(dao, config, interface).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::init(dao, config, interface).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::init(dao, config, interface).unwrap();
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let check_result = with_token(token.clone(), async {
GarrisonUtil::check_role("admin").await
})
.await;
assert!(
check_result.is_ok(),
"持有角色应通过: {:?}",
check_result.map(|_| ())
);
let check_result = with_token(token.clone(), 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::init(dao.clone(), config.clone(), interface.clone()).unwrap();
assert!(GarrisonManager::is_initialized());
let result = GarrisonManager::init(dao, config, interface);
assert!(
result.is_ok(),
"重复 init 应覆盖式更新: {:?}",
result.map(|_| ())
);
assert!(GarrisonManager::is_initialized());
GarrisonManager::reset_for_test();
}
#[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
);
}
#[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));
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(not(feature = "listener"))]
let ctx = GarrisonLogicFactoryContext {
plugin_manager: None,
auth_logic: None,
permission_checker: None,
disable_repository: 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::init(dao, config, interface);
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::init(dao, config, interface);
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::init(dao, config, interface);
assert!(result.is_err());
assert!(
matches!(result.unwrap_err(), GarrisonError::Config(ref msg) if msg.contains("unknown token_style")),
"应返回 'unknown token_style' 错误"
);
assert!(!GarrisonManager::is_initialized());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn init_fallback_when_no_factory_registered() {
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::init_with_factory_selector(
dao,
config,
interface,
|| None, );
assert!(result.is_ok(), "兜底路径应成功: {:?}", 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!(result.is_err());
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::init(dao, config, interface).unwrap();
let strategy = GarrisonManager::strategy();
assert!(strategy.is_ok(), "init 后应能获取 strategy");
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::init(dao, config, interface).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::init(dao, config, interface).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::init(dao, config, interface).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::init(dao, config, interface).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::init(dao, config, interface).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::init(dao, config, interface).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::init(dao, config, interface).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::init(dao, config, interface).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::init(dao, config, interface).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"
);
tokio::time::sleep(std::time::Duration::from_secs(3)).await;
assert!(
logic.session.get_token_by_login_id("1001").is_none(),
"清理后 token 应从 login_token_map 移除"
);
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(())
}
}
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));
session.add_login_token("user1", "token1");
let handle = spawn_cleanup_task(session, 1).unwrap();
let manager = GarrisonManager::new();
*manager.cleanup_task_handle.write() = Some(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
);
}