use crate::error::GarrisonResult;
use crate::stp::{GarrisonLogicDefault, LoginParams, PermissionLogic, SessionLogic, TokenLogic};
#[cfg(any(
feature = "sms-rate-limit",
feature = "firewall-ratelimit",
feature = "firewall-bruteforce",
feature = "firewall-ddos",
feature = "firewall",
feature = "oauth2-server"
))]
use crate::strategy::hooks::LoginContext;
use async_trait::async_trait;
use std::sync::Arc;
#[async_trait]
pub trait LoginHandler: Send + Sync {
async fn handle_login(&self, login_id: &str) -> GarrisonResult<String>;
}
#[async_trait]
pub trait LogoutHandler: Send + Sync {
async fn handle_logout(&self) -> GarrisonResult<()>;
async fn handle_logout_by_login_id(&self, login_id: &str) -> GarrisonResult<()>;
}
#[async_trait]
pub trait PermissionHandler: Send + Sync {
async fn handle_check_permission(&self, permission: &str) -> GarrisonResult<()>;
async fn handle_check_role(&self, role: &str) -> GarrisonResult<()>;
}
#[async_trait]
pub trait TokenGenerator: Send + Sync {
async fn generate_token(&self, login_id: &str) -> GarrisonResult<String>;
async fn refresh_token(&self, token: &str) -> GarrisonResult<String>;
}
#[async_trait]
pub trait SessionCreator: Send + Sync {
async fn create_session(&self, login_id: &str, token: &str) -> GarrisonResult<()>;
async fn check_login(&self) -> GarrisonResult<bool>;
}
#[async_trait]
pub trait FirewallStrategy: Send + Sync {
#[cfg(any(
feature = "sms-rate-limit",
feature = "firewall-ratelimit",
feature = "firewall-bruteforce",
feature = "firewall-ddos",
feature = "firewall",
feature = "oauth2-server"
))]
async fn check_login_hooks(&self, login_id: &str, ctx: &LoginContext) -> GarrisonResult<()>;
}
pub struct DefaultLoginHandler {
logic: Arc<GarrisonLogicDefault>,
}
impl DefaultLoginHandler {
pub fn new(logic: Arc<GarrisonLogicDefault>) -> Self {
Self { logic }
}
}
#[async_trait]
impl LoginHandler for DefaultLoginHandler {
async fn handle_login(&self, login_id: &str) -> GarrisonResult<String> {
self.logic.login(login_id, &LoginParams::default()).await
}
}
pub struct DefaultLogoutHandler {
logic: Arc<GarrisonLogicDefault>,
}
impl DefaultLogoutHandler {
pub fn new(logic: Arc<GarrisonLogicDefault>) -> Self {
Self { logic }
}
}
#[async_trait]
impl LogoutHandler for DefaultLogoutHandler {
async fn handle_logout(&self) -> GarrisonResult<()> {
self.logic.logout().await
}
async fn handle_logout_by_login_id(&self, login_id: &str) -> GarrisonResult<()> {
self.logic.logout_by_login_id(login_id).await
}
}
pub struct DefaultPermissionHandler {
logic: Arc<GarrisonLogicDefault>,
}
impl DefaultPermissionHandler {
pub fn new(logic: Arc<GarrisonLogicDefault>) -> Self {
Self { logic }
}
}
#[async_trait]
impl PermissionHandler for DefaultPermissionHandler {
async fn handle_check_permission(&self, permission: &str) -> GarrisonResult<()> {
self.logic.check_permission(permission).await
}
async fn handle_check_role(&self, role: &str) -> GarrisonResult<()> {
self.logic.check_role(role).await
}
}
pub struct DefaultTokenGenerator {
logic: Arc<GarrisonLogicDefault>,
}
impl DefaultTokenGenerator {
pub fn new(logic: Arc<GarrisonLogicDefault>) -> Self {
Self { logic }
}
}
#[async_trait]
impl TokenGenerator for DefaultTokenGenerator {
async fn generate_token(&self, login_id: &str) -> GarrisonResult<String> {
self.logic.login(login_id, &LoginParams::default()).await
}
async fn refresh_token(&self, token: &str) -> GarrisonResult<String> {
self.logic.refresh_token(token).await
}
}
pub struct DefaultSessionCreator {
logic: Arc<GarrisonLogicDefault>,
}
impl DefaultSessionCreator {
pub fn new(logic: Arc<GarrisonLogicDefault>) -> Self {
Self { logic }
}
}
#[async_trait]
impl SessionCreator for DefaultSessionCreator {
async fn create_session(&self, login_id: &str, token: &str) -> GarrisonResult<()> {
self.logic.login_with_token(login_id, token).await
}
async fn check_login(&self) -> GarrisonResult<bool> {
self.logic.check_login().await
}
}
pub struct DefaultFirewallStrategy;
impl DefaultFirewallStrategy {
pub fn new(_logic: Arc<GarrisonLogicDefault>) -> Self {
Self
}
}
#[async_trait]
impl FirewallStrategy for DefaultFirewallStrategy {
#[cfg(any(
feature = "sms-rate-limit",
feature = "firewall-ratelimit",
feature = "firewall-bruteforce",
feature = "firewall-ddos",
feature = "firewall",
feature = "oauth2-server"
))]
async fn check_login_hooks(&self, _login_id: &str, _ctx: &LoginContext) -> GarrisonResult<()> {
Ok(())
}
}
pub struct Strategy {
login_handler: Arc<dyn LoginHandler>,
logout_handler: Arc<dyn LogoutHandler>,
permission_handler: Arc<dyn PermissionHandler>,
token_generator: Arc<dyn TokenGenerator>,
session_creator: Arc<dyn SessionCreator>,
firewall_strategy: Arc<dyn FirewallStrategy>,
default_login_handler: Arc<dyn LoginHandler>,
default_logout_handler: Arc<dyn LogoutHandler>,
default_permission_handler: Arc<dyn PermissionHandler>,
default_token_generator: Arc<dyn TokenGenerator>,
default_session_creator: Arc<dyn SessionCreator>,
default_firewall_strategy: Arc<dyn FirewallStrategy>,
}
impl Strategy {
pub fn new(logic: Arc<GarrisonLogicDefault>) -> Self {
let login_handler: Arc<dyn LoginHandler> =
Arc::new(DefaultLoginHandler::new(logic.clone()));
let logout_handler: Arc<dyn LogoutHandler> =
Arc::new(DefaultLogoutHandler::new(logic.clone()));
let permission_handler: Arc<dyn PermissionHandler> =
Arc::new(DefaultPermissionHandler::new(logic.clone()));
let token_generator: Arc<dyn TokenGenerator> =
Arc::new(DefaultTokenGenerator::new(logic.clone()));
let session_creator: Arc<dyn SessionCreator> =
Arc::new(DefaultSessionCreator::new(logic.clone()));
let firewall_strategy: Arc<dyn FirewallStrategy> =
Arc::new(DefaultFirewallStrategy::new(logic));
Self {
login_handler: login_handler.clone(),
logout_handler: logout_handler.clone(),
permission_handler: permission_handler.clone(),
token_generator: token_generator.clone(),
session_creator: session_creator.clone(),
firewall_strategy: firewall_strategy.clone(),
default_login_handler: login_handler,
default_logout_handler: logout_handler,
default_permission_handler: permission_handler,
default_token_generator: token_generator,
default_session_creator: session_creator,
default_firewall_strategy: firewall_strategy,
}
}
pub fn register_login_handler(&mut self, handler: Arc<dyn LoginHandler>) {
self.login_handler = handler;
}
pub fn login_handler(&self) -> &Arc<dyn LoginHandler> {
&self.login_handler
}
pub fn remove_login_handler(&mut self) {
self.login_handler = self.default_login_handler.clone();
}
pub fn register_logout_handler(&mut self, handler: Arc<dyn LogoutHandler>) {
self.logout_handler = handler;
}
pub fn logout_handler(&self) -> &Arc<dyn LogoutHandler> {
&self.logout_handler
}
pub fn remove_logout_handler(&mut self) {
self.logout_handler = self.default_logout_handler.clone();
}
pub fn register_permission_handler(&mut self, handler: Arc<dyn PermissionHandler>) {
self.permission_handler = handler;
}
pub fn permission_handler(&self) -> &Arc<dyn PermissionHandler> {
&self.permission_handler
}
pub fn remove_permission_handler(&mut self) {
self.permission_handler = self.default_permission_handler.clone();
}
pub fn register_token_generator(&mut self, generator: Arc<dyn TokenGenerator>) {
self.token_generator = generator;
}
pub fn token_generator(&self) -> &Arc<dyn TokenGenerator> {
&self.token_generator
}
pub fn remove_token_generator(&mut self) {
self.token_generator = self.default_token_generator.clone();
}
pub fn register_session_creator(&mut self, creator: Arc<dyn SessionCreator>) {
self.session_creator = creator;
}
pub fn session_creator(&self) -> &Arc<dyn SessionCreator> {
&self.session_creator
}
pub fn remove_session_creator(&mut self) {
self.session_creator = self.default_session_creator.clone();
}
pub fn register_firewall_strategy(&mut self, strategy: Arc<dyn FirewallStrategy>) {
self.firewall_strategy = strategy;
}
pub fn firewall_strategy(&self) -> &Arc<dyn FirewallStrategy> {
&self.firewall_strategy
}
pub fn remove_firewall_strategy(&mut self) {
self.firewall_strategy = self.default_firewall_strategy.clone();
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::GarrisonConfig;
use crate::dao::tests::MockDao;
use crate::dao::GarrisonDao;
use crate::session::GarrisonSession;
use crate::stp::{GarrisonInterface, GarrisonLogicDefault};
use crate::strategy::GarrisonPermissionStrategyDefault;
use async_trait::async_trait;
use serial_test::serial;
use std::collections::HashMap;
struct MockInterface {
permissions: HashMap<String, Vec<String>>,
roles: HashMap<String, Vec<String>>,
}
impl MockInterface {
fn new() -> Self {
Self {
permissions: HashMap::new(),
roles: HashMap::new(),
}
}
}
#[async_trait]
impl GarrisonInterface for MockInterface {
async fn get_permission_list(&self, login_id: &str) -> GarrisonResult<Vec<String>> {
Ok(self.permissions.get(login_id).cloned().unwrap_or_default())
}
async fn get_role_list(&self, login_id: &str) -> GarrisonResult<Vec<String>> {
Ok(self.roles.get(login_id).cloned().unwrap_or_default())
}
}
fn make_logic() -> Arc<GarrisonLogicDefault> {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(GarrisonConfig::default_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
let timeout = u64::try_from(config.timeout).unwrap_or(3600);
let session = Arc::new(GarrisonSession::new(dao.clone(), timeout, timeout, 0));
let firewall: Arc<dyn crate::strategy::GarrisonPermissionStrategy> =
Arc::new(GarrisonPermissionStrategyDefault::new(interface));
Arc::new(GarrisonLogicDefault::new(
session,
config,
firewall,
Arc::new(crate::account::disable::DefaultDisableRepository::new(
dao.clone(),
)),
))
}
#[tokio::test]
async fn login_handler_trait_can_be_implemented() {
struct MyLoginHandler;
#[async_trait]
impl LoginHandler for MyLoginHandler {
async fn handle_login(&self, login_id: &str) -> GarrisonResult<String> {
Ok(format!("token-{}", login_id))
}
}
let handler = MyLoginHandler;
assert_eq!(handler.handle_login("1001").await.unwrap(), "token-1001");
}
#[tokio::test]
async fn logout_handler_trait_can_be_implemented() {
struct MyLogoutHandler;
#[async_trait]
impl LogoutHandler for MyLogoutHandler {
async fn handle_logout(&self) -> GarrisonResult<()> {
Ok(())
}
async fn handle_logout_by_login_id(&self, _login_id: &str) -> GarrisonResult<()> {
Ok(())
}
}
let handler = MyLogoutHandler;
assert!(handler.handle_logout().await.is_ok());
assert!(handler.handle_logout_by_login_id("1001").await.is_ok());
}
#[tokio::test]
async fn permission_handler_trait_can_be_implemented() {
struct MyPermissionHandler;
#[async_trait]
impl PermissionHandler for MyPermissionHandler {
async fn handle_check_permission(&self, _permission: &str) -> GarrisonResult<()> {
Ok(())
}
async fn handle_check_role(&self, _role: &str) -> GarrisonResult<()> {
Ok(())
}
}
let handler = MyPermissionHandler;
assert!(handler.handle_check_permission("user:read").await.is_ok());
assert!(handler.handle_check_role("admin").await.is_ok());
}
#[tokio::test]
async fn token_generator_trait_can_be_implemented() {
struct MyTokenGenerator;
#[async_trait]
impl TokenGenerator for MyTokenGenerator {
async fn generate_token(&self, login_id: &str) -> GarrisonResult<String> {
Ok(format!("gen-{}", login_id))
}
async fn refresh_token(&self, token: &str) -> GarrisonResult<String> {
Ok(format!("refreshed-{}", token))
}
}
let gen = MyTokenGenerator;
assert_eq!(gen.generate_token("1001").await.unwrap(), "gen-1001");
assert_eq!(gen.refresh_token("old").await.unwrap(), "refreshed-old");
}
#[tokio::test]
async fn session_creator_trait_can_be_implemented() {
struct MySessionCreator;
#[async_trait]
impl SessionCreator for MySessionCreator {
async fn create_session(&self, _login_id: &str, _token: &str) -> GarrisonResult<()> {
Ok(())
}
async fn check_login(&self) -> GarrisonResult<bool> {
Ok(true)
}
}
let creator = MySessionCreator;
assert!(creator.create_session("1001", "tok").await.is_ok());
assert!(creator.check_login().await.unwrap());
}
#[cfg(any(
feature = "sms-rate-limit",
feature = "firewall-ratelimit",
feature = "firewall-bruteforce",
feature = "firewall-ddos",
feature = "firewall",
feature = "oauth2-server"
))]
#[tokio::test]
async fn firewall_strategy_trait_can_be_implemented() {
struct MyFirewallStrategy;
#[async_trait]
impl FirewallStrategy for MyFirewallStrategy {
async fn check_login_hooks(
&self,
_login_id: &str,
_ctx: &LoginContext,
) -> GarrisonResult<()> {
Ok(())
}
}
let fw = MyFirewallStrategy;
let ctx = LoginContext::new("1001");
assert!(fw.check_login_hooks("1001", &ctx).await.is_ok());
}
#[tokio::test]
async fn strategy_new_initializes_with_logic() {
let logic = make_logic();
let strategy = Strategy::new(logic);
let _ = strategy.login_handler();
let _ = strategy.logout_handler();
let _ = strategy.permission_handler();
let _ = strategy.token_generator();
let _ = strategy.session_creator();
let _ = strategy.firewall_strategy();
}
#[tokio::test]
#[serial]
async fn default_login_handler_delegates_to_logic() {
let logic = make_logic();
let strategy = Strategy::new(logic);
let token = strategy.login_handler().handle_login("1001").await.unwrap();
assert!(
!token.is_empty(),
"默认登录策略应委托 logic.login 生成 token"
);
}
#[tokio::test]
async fn strategy_register_replaces_login_handler() {
let logic = make_logic();
let mut strategy = Strategy::new(logic);
struct CustomLoginHandler;
#[async_trait]
impl LoginHandler for CustomLoginHandler {
async fn handle_login(&self, login_id: &str) -> GarrisonResult<String> {
Ok(format!("custom-{}", login_id))
}
}
strategy.register_login_handler(Arc::new(CustomLoginHandler));
let token = strategy.login_handler().handle_login("1001").await.unwrap();
assert_eq!(token, "custom-1001", "register 后应使用自定义策略");
}
#[tokio::test]
async fn strategy_get_returns_current_handler() {
let logic = make_logic();
let mut strategy = Strategy::new(logic);
struct TrackingLoginHandler {
id: i32,
}
#[async_trait]
impl LoginHandler for TrackingLoginHandler {
async fn handle_login(&self, login_id: &str) -> GarrisonResult<String> {
Ok(format!("{}-{}", self.id, login_id))
}
}
let default_token = strategy.login_handler().handle_login("1").await.unwrap();
assert!(
!default_token.starts_with("42-"),
"默认策略不应是 TrackingLoginHandler"
);
strategy.register_login_handler(Arc::new(TrackingLoginHandler { id: 42 }));
let custom_token = strategy.login_handler().handle_login("1").await.unwrap();
assert_eq!(custom_token, "42-1", "get 应返回当前注册的策略");
}
#[tokio::test]
async fn strategy_remove_restores_default_login_handler() {
let logic = make_logic();
let mut strategy = Strategy::new(logic);
struct CustomLoginHandler;
#[async_trait]
impl LoginHandler for CustomLoginHandler {
async fn handle_login(&self, login_id: &str) -> GarrisonResult<String> {
Ok(format!("custom-{}", login_id))
}
}
strategy.register_login_handler(Arc::new(CustomLoginHandler));
let custom_token = strategy.login_handler().handle_login("1001").await.unwrap();
assert_eq!(custom_token, "custom-1001");
strategy.remove_login_handler();
let restored_token = strategy.login_handler().handle_login("1001").await.unwrap();
assert_ne!(restored_token, "custom-1001", "remove 后应恢复默认策略");
}
#[tokio::test]
async fn strategy_all_six_strategies_have_register_get_remove() {
let logic = make_logic();
let mut strategy = Strategy::new(logic);
let _ = strategy.login_handler();
let _ = strategy.logout_handler();
let _ = strategy.permission_handler();
let _ = strategy.token_generator();
let _ = strategy.session_creator();
let _ = strategy.firewall_strategy();
strategy.remove_login_handler();
strategy.remove_logout_handler();
strategy.remove_permission_handler();
strategy.remove_token_generator();
strategy.remove_session_creator();
strategy.remove_firewall_strategy();
struct CustomLogin;
#[async_trait]
impl LoginHandler for CustomLogin {
async fn handle_login(&self, id: &str) -> GarrisonResult<String> {
Ok(format!("c-{}", id))
}
}
strategy.register_login_handler(Arc::new(CustomLogin));
strategy.remove_login_handler();
}
#[tokio::test]
async fn strategy_replace_one_does_not_affect_others() {
let logic = make_logic();
let mut strategy = Strategy::new(logic);
struct CustomLoginHandler;
#[async_trait]
impl LoginHandler for CustomLoginHandler {
async fn handle_login(&self, login_id: &str) -> GarrisonResult<String> {
Ok(format!("custom-{}", login_id))
}
}
let original_logout = strategy.logout_handler().clone();
strategy.register_login_handler(Arc::new(CustomLoginHandler));
assert!(
Arc::ptr_eq(&original_logout, strategy.logout_handler()),
"替换 LoginHandler 不应影响 LogoutHandler"
);
let token = strategy.login_handler().handle_login("1001").await.unwrap();
assert_eq!(token, "custom-1001");
}
#[tokio::test]
async fn strategy_replace_drops_old_handler() {
let logic = make_logic();
let mut strategy = Strategy::new(logic);
struct CustomLoginHandler;
#[async_trait]
impl LoginHandler for CustomLoginHandler {
async fn handle_login(&self, login_id: &str) -> GarrisonResult<String> {
Ok(format!("v1-{}", login_id))
}
}
let handler_v1 = Arc::new(CustomLoginHandler);
let weak_v1 = Arc::downgrade(&handler_v1);
strategy.register_login_handler(handler_v1);
struct AnotherLoginHandler;
#[async_trait]
impl LoginHandler for AnotherLoginHandler {
async fn handle_login(&self, login_id: &str) -> GarrisonResult<String> {
Ok(format!("v2-{}", login_id))
}
}
strategy.register_login_handler(Arc::new(AnotherLoginHandler));
assert!(
weak_v1.upgrade().is_none(),
"替换后旧策略应被 drop,无内存泄漏"
);
}
#[cfg(any(
feature = "sms-rate-limit",
feature = "firewall-ratelimit",
feature = "firewall-bruteforce",
feature = "firewall-ddos",
feature = "firewall",
feature = "oauth2-server"
))]
#[tokio::test]
async fn default_firewall_strategy_is_noop() {
let logic = make_logic();
let strategy = Strategy::new(logic);
let ctx = LoginContext::new("1001");
let result = strategy
.firewall_strategy()
.check_login_hooks("1001", &ctx)
.await;
assert!(result.is_ok(), "默认防火墙策略应为 no-op 返回 Ok");
}
#[tokio::test]
#[serial]
async fn default_session_creator_delegates_to_logic() {
let logic = make_logic();
let strategy = Strategy::new(logic);
let result = strategy
.session_creator()
.create_session("1001", "test-token")
.await;
assert!(
result.is_ok(),
"默认会话创建策略应委托 logic.login_with_token"
);
}
#[tokio::test]
#[serial]
async fn default_permission_handler_delegates_to_logic() {
let logic = make_logic();
let strategy = Strategy::new(logic);
let result = strategy
.permission_handler()
.handle_check_permission("user:read")
.await;
assert!(
result.is_err(),
"未登录时默认权限策略应委托 logic.check_permission 返回 Err"
);
}
#[tokio::test]
#[serial]
async fn default_logout_handler_handle_logout_delegates() {
let logic = make_logic();
let strategy = Strategy::new(logic);
let result = strategy.logout_handler().handle_logout().await;
assert!(
result.is_ok(),
"未登录时 handle_logout 应幂等返回 Ok,实际: {:?}",
result
);
}
#[tokio::test]
#[serial]
async fn default_logout_handler_handle_logout_by_login_id_delegates() {
let logic = make_logic();
let strategy = Strategy::new(logic);
let result = strategy
.logout_handler()
.handle_logout_by_login_id("99999")
.await;
assert!(
result.is_ok(),
"handle_logout_by_login_id 不存在的 login_id 应幂等返回 Ok,实际: {:?}",
result
);
}
#[tokio::test]
#[serial]
async fn default_permission_handler_handle_check_role_delegates() {
let logic = make_logic();
let strategy = Strategy::new(logic);
let result = strategy
.permission_handler()
.handle_check_role("admin")
.await;
assert!(
result.is_err(),
"未登录时 handle_check_role 应委托 logic.check_role 返回 Err"
);
}
#[tokio::test]
#[serial]
async fn default_token_generator_generate_token_delegates() {
let logic = make_logic();
let strategy = Strategy::new(logic);
let result = strategy.token_generator().generate_token("1001").await;
assert!(
result.is_ok(),
"generate_token 应委托 logic.login 返回 token,实际: {:?}",
result
);
let token = result.unwrap();
assert!(!token.is_empty(), "生成的 token 不应为空");
}
#[tokio::test]
#[serial]
async fn default_token_generator_refresh_token_delegates() {
let logic = make_logic();
let strategy = Strategy::new(logic);
let result = strategy
.token_generator()
.refresh_token("invalid-token-for-refresh")
.await;
assert!(
result.is_err(),
"refresh_token 无效 token 应委托 logic.refresh_token 返回 Err"
);
}
#[tokio::test]
#[serial]
async fn default_session_creator_check_login_delegates() {
let logic = make_logic();
let strategy = Strategy::new(logic);
let result = strategy.session_creator().check_login().await;
assert!(
result.is_err(),
"默认 throw_on_not_login=true,未登录时应返回 Err,实际: {:?}",
result
);
}
#[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();
}
}