pub mod security_listener;
pub use security_listener::SessionSecurityListener;
#[cfg(any(
feature = "protocol-jwt",
feature = "account-credential",
feature = "protocol-oauth2",
feature = "protocol-sso",
feature = "protocol-sign",
feature = "secure-sign",
feature = "protocol-httpdigest"
))]
pub mod device;
#[cfg(any(
feature = "protocol-jwt",
feature = "account-credential",
feature = "protocol-oauth2",
feature = "protocol-sso",
feature = "protocol-sign",
feature = "secure-sign",
feature = "protocol-httpdigest"
))]
pub use device::{DeviceManager, DeviceSession};
#[cfg(feature = "session-extra")]
pub mod anon;
#[cfg(feature = "session-extra")]
pub mod search;
#[cfg(feature = "session-extra")]
pub use search::SearchSortType;
use crate::constants::DaoKeyPrefix;
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use async_trait::async_trait;
use chrono::Utc;
use dashmap::DashMap;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::Mutex as TokioMutex;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TokenInfo {
pub token: String,
pub created_at: i64,
pub last_active_at: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AccountSession {
pub login_id: String,
pub tokens: Vec<TokenInfo>,
pub created_at: i64,
pub last_active_at: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TokenSession {
pub token: String,
pub login_id: String,
pub created_at: i64,
pub last_active_at: i64,
pub attrs: HashMap<String, String>,
#[serde(default)]
pub device: Option<String>,
#[serde(default)]
pub ip: Option<String>,
#[serde(default)]
pub user_agent: Option<String>,
#[serde(default)]
pub safe_services: HashMap<String, i64>,
#[cfg(feature = "session-extra")]
#[serde(default)]
pub dynamic_active_timeout: Option<i64>,
#[cfg(feature = "session-extra")]
#[serde(default)]
pub is_anon: bool,
#[serde(default)]
pub effective_timeout: Option<i64>,
#[serde(default)]
pub amr_ledger: Vec<crate::stp::mfa::AmrEntry>,
#[serde(default)]
pub auth_time: Option<i64>,
}
#[async_trait]
pub trait SessionExpiryListener: Send + Sync {
async fn on_session_expired(&self, login_id: &str, token: &str) -> GarrisonResult<()>;
}
pub struct GarrisonSession {
dao: Arc<dyn GarrisonDao>,
timeout: u64,
active_timeout: u64,
remember_me_timeout: u64,
#[cfg(feature = "session-extra")]
anon_session_timeout: u64,
login_locks: DashMap<String, Arc<TokioMutex<()>>>,
token_session_locks: DashMap<String, Arc<TokioMutex<()>>>,
login_token_map: DashMap<String, Vec<String>>,
#[cfg(feature = "listener")]
listener_manager: Option<Arc<crate::listener::GarrisonListenerManager>>,
expiry_listeners: Vec<Arc<dyn SessionExpiryListener>>,
last_active_time: DashMap<String, i64>,
}
pub(crate) fn account_key(login_id: &str) -> String {
format!("account:session:{}", login_id)
}
pub fn token_key(token: &str) -> String {
format!("{}session:{}", DaoKeyPrefix::Token, sha256_hex(token))
}
fn sha256_hex(input: &str) -> String {
use sha2::{Digest, Sha256};
Sha256::digest(input.as_bytes())
.iter()
.map(|b| format!("{b:02x}"))
.collect()
}
mod r#impl;
#[cfg(test)]
mod mock;
#[cfg(test)]
mod tests {
use super::mock::MockExpiryListener;
use super::*;
use crate::dao::tests::MockDao;
use crate::stp::LoginParams;
use async_trait::async_trait;
use std::time::Duration;
fn make_session(timeout: u64, active_timeout: u64) -> (Arc<MockDao>, GarrisonSession) {
let dao = Arc::new(MockDao::new());
let session = GarrisonSession::new(dao.clone(), timeout, active_timeout, 0);
(dao, session)
}
#[tokio::test]
async fn create_writes_both_sessions() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert_eq!(ts.login_id, "1001");
assert_eq!(ts.token, "T1");
assert!(ts.created_at > 0);
assert_eq!(ts.created_at, ts.last_active_at);
let as_ = session.get_account_session("1001").await.unwrap().unwrap();
assert_eq!(as_.login_id, "1001");
assert_eq!(as_.tokens.len(), 1);
assert_eq!(as_.tokens[0].token, "T1");
}
#[tokio::test]
async fn dao_key_format_matches_spec() {
let (dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let account_json = dao.get("account:session:1001").await.unwrap();
assert!(account_json.is_some());
let account: AccountSession = serde_json::from_str(&account_json.unwrap()).unwrap();
assert_eq!(account.login_id, "1001");
let key = token_key("T1");
assert!(
key.starts_with("token:session:"),
"Token-Session key 应以 `token:session:` 为前缀,实际: {key}"
);
let digest = &key["token:session:".len()..];
assert_eq!(digest.len(), 64, "摘要余段应为 64 位 hex");
assert!(
digest
.bytes()
.all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)),
"摘要余段应为小写 hex,实际: {digest}"
);
assert_eq!(key, token_key("T1"), "同一 token 的 key 构造应确定");
assert_ne!(key, token_key("T2"), "不同 token 的 key 不应碰撞");
let token_json = dao.get(&key).await.unwrap();
assert!(token_json.is_some());
let ts: TokenSession = serde_json::from_str(&token_json.unwrap()).unwrap();
assert_eq!(ts.login_id, "1001");
}
#[tokio::test]
async fn account_session_records_multiple_tokens() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.create("1001", "T2").await.unwrap();
let as_ = session.get_account_session("1001").await.unwrap().unwrap();
assert_eq!(as_.tokens.len(), 2);
assert_eq!(as_.tokens[0].token, "T1");
assert_eq!(as_.tokens[1].token, "T2");
}
#[tokio::test]
async fn account_session_removes_token_on_logout() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.create("1001", "T2").await.unwrap();
session.logout("T1").await.unwrap();
let as_ = session.get_account_session("1001").await.unwrap().unwrap();
assert_eq!(as_.tokens.len(), 1);
assert_eq!(as_.tokens[0].token, "T2");
}
#[tokio::test]
async fn account_session_keeps_history_when_empty() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.logout("T1").await.unwrap();
let as_ = session.get_account_session("1001").await.unwrap();
assert!(as_.is_some(), "Account-Session 应保留(保留历史)");
assert!(as_.unwrap().tokens.is_empty());
}
#[tokio::test]
async fn token_session_stores_custom_attrs() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.set("T1", "ip", "192.168.1.1").await.unwrap();
let ip = session.get("T1", "ip").await.unwrap();
assert_eq!(ip, Some("192.168.1.1".to_string()));
}
#[tokio::test]
async fn set_attr_nonexistent_token_errors() {
let (_dao, session) = make_session(3600, 86400);
let result = session.set("nonexistent", "ip", "1.2.3.4").await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"set 不存在的 token 应返回 InvalidToken"
);
}
#[tokio::test]
async fn is_valid_returns_false_for_nonexistent_token() {
let (_dao, session) = make_session(3600, 86400);
let valid = session.is_valid("nonexistent").await.unwrap();
assert!(!valid);
}
#[tokio::test]
async fn is_valid_returns_true_for_active_token() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let valid = session.is_valid("T1").await.unwrap();
assert!(valid);
}
#[tokio::test]
async fn is_valid_returns_false_when_account_session_expired() {
let (dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
dao.delete(&account_key("1001")).await.unwrap();
let token_exists = session.get_token_session("T1").await.unwrap();
assert!(token_exists.is_some(), "Token-Session 仍应存在");
let valid = session.is_valid("T1").await.unwrap();
assert!(!valid, "Account-Session 过期后 token 应视为无效");
}
#[tokio::test]
async fn touch_updates_last_active_and_renews_ttl() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
tokio::time::sleep(Duration::from_millis(1500)).await;
session.touch("T1").await.unwrap();
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert!(
ts.last_active_at > ts.created_at,
"touch 后 last_active_at 应大于 created_at"
);
let as_ = session.get_account_session("1001").await.unwrap().unwrap();
assert_eq!(as_.last_active_at, ts.last_active_at);
let ti = as_.tokens.iter().find(|t| t.token == "T1").unwrap();
assert_eq!(ti.last_active_at, ts.last_active_at);
}
#[tokio::test]
async fn renew_resets_ttl() {
let (_dao, session) = make_session(5, 86400);
session.create("1001", "T1").await.unwrap();
tokio::time::sleep(Duration::from_secs(1)).await;
session.renew("T1").await.unwrap();
tokio::time::sleep(Duration::from_secs(2)).await;
let valid = session.is_valid("T1").await.unwrap();
assert!(
valid,
"renew 后 token 应仍有效(TTL 已重置,还有 3 秒 margin)"
);
}
#[tokio::test]
async fn renew_nonexistent_token_errors() {
let (_dao, session) = make_session(3600, 86400);
let result = session.renew("nonexistent").await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"renew 不存在的 token 应返回 InvalidToken"
);
}
#[tokio::test]
async fn logout_removes_token_session() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.logout("T1").await.unwrap();
let ts = session.get_token_session("T1").await.unwrap();
assert!(ts.is_none(), "logout 后 Token-Session 应删除");
}
#[tokio::test]
async fn logout_by_login_id_removes_all() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.create("1001", "T2").await.unwrap();
session.logout_by_login_id("1001").await.unwrap();
assert!(session.get_token_session("T1").await.unwrap().is_none());
assert!(session.get_token_session("T2").await.unwrap().is_none());
assert!(session.get_account_session("1001").await.unwrap().is_none());
}
#[tokio::test]
async fn logout_nonexistent_token_is_noop() {
let (_dao, session) = make_session(3600, 86400);
let result = session.logout("nonexistent").await;
assert!(result.is_ok());
}
#[tokio::test]
async fn get_token_session_corrupt_json_errors() {
let (dao, session) = make_session(3600, 86400);
dao.set(&token_key("corrupt"), "not-a-valid-json", 3600)
.await
.unwrap();
let result = session.get_token_session("corrupt").await;
assert!(
matches!(result, Err(GarrisonError::Session(ref msg)) if msg.contains("session-sim-token-deserialize")),
"非法 JSON 应返回 'session-sim-token-deserialize' 错误,实际: {:?}",
result
);
}
#[tokio::test]
async fn get_account_session_corrupt_json_errors() {
let (dao, session) = make_session(3600, 86400);
dao.set(&account_key("2001"), "{invalid-json", 3600)
.await
.unwrap();
let result = session.get_account_session("2001").await;
assert!(
matches!(result, Err(GarrisonError::Session(ref msg)) if msg.contains("session-sim-account-deserialize")),
"非法 JSON 应返回 'session-sim-account-deserialize' 错误,实际: {:?}",
result
);
}
#[tokio::test]
async fn touch_nonexistent_token_errors() {
let (_dao, session) = make_session(3600, 86400);
let result = session.touch("nonexistent").await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"touch 不存在的 token 应返回 InvalidToken 错误"
);
}
#[tokio::test]
async fn get_attr_nonexistent_token_returns_none() {
let (_dao, session) = make_session(3600, 86400);
let result = session.get("nonexistent", "key").await.unwrap();
assert!(result.is_none(), "token 不存在时 get 属性应返回 None");
}
#[tokio::test]
async fn create_appends_to_existing_account_session() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.create("1001", "T2").await.unwrap();
session.create("1001", "T3").await.unwrap();
let as_ = session.get_account_session("1001").await.unwrap().unwrap();
assert_eq!(as_.tokens.len(), 3, "三次 login 后应有 3 个 token");
assert_eq!(as_.tokens[0].token, "T1");
assert_eq!(as_.tokens[1].token, "T2");
assert_eq!(as_.tokens[2].token, "T3");
}
#[tokio::test]
async fn link_sso_ticket_stores_ticket_in_token_session() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session
.link_sso_ticket("T1", "ticket-abc-123")
.await
.unwrap();
let ticket = session.get_sso_ticket("T1").await.unwrap();
assert_eq!(ticket, Some("ticket-abc-123".to_string()));
}
#[tokio::test]
async fn get_sso_ticket_returns_none_when_not_linked() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let ticket = session.get_sso_ticket("T1").await.unwrap();
assert!(ticket.is_none(), "未关联 ticket 时应返回 None");
}
#[tokio::test]
async fn get_sso_ticket_returns_none_for_nonexistent_token() {
let (_dao, session) = make_session(3600, 86400);
let ticket = session.get_sso_ticket("nonexistent").await.unwrap();
assert!(ticket.is_none(), "token 不存在时应返回 None");
}
#[tokio::test]
async fn link_oauth2_token_stores_access_token_in_token_session() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session
.link_oauth2_token("T1", "access-token-xyz")
.await
.unwrap();
let access_token = session.get_oauth2_token("T1").await.unwrap();
assert_eq!(access_token, Some("access-token-xyz".to_string()));
}
#[tokio::test]
async fn get_oauth2_token_returns_none_when_not_linked() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let access_token = session.get_oauth2_token("T1").await.unwrap();
assert!(access_token.is_none(), "未关联 access_token 时应返回 None");
}
#[tokio::test]
async fn get_oauth2_token_returns_none_for_nonexistent_token() {
let (_dao, session) = make_session(3600, 86400);
let access_token = session.get_oauth2_token("nonexistent").await.unwrap();
assert!(access_token.is_none(), "token 不存在时应返回 None");
}
#[tokio::test]
async fn link_temp_credential_stores_key_in_token_session() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let temp_key = "garrison:temp:order:abc123";
session.link_temp_credential("T1", temp_key).await.unwrap();
let stored = session.get_temp_credential("T1").await.unwrap();
assert_eq!(stored, Some(temp_key.to_string()));
}
#[tokio::test]
async fn get_temp_credential_returns_none_when_not_linked() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let stored = session.get_temp_credential("T1").await.unwrap();
assert!(stored.is_none(), "未关联临时凭证时应返回 None");
}
#[tokio::test]
async fn get_temp_credential_returns_none_for_nonexistent_token() {
let (_dao, session) = make_session(3600, 86400);
let stored = session.get_temp_credential("nonexistent").await.unwrap();
assert!(stored.is_none(), "token 不存在时应返回 None");
}
#[tokio::test]
async fn link_methods_return_error_for_nonexistent_token() {
let (_dao, session) = make_session(3600, 86400);
let r1 = session.link_sso_ticket("nonexistent", "ticket").await;
assert!(
matches!(r1, Err(GarrisonError::InvalidToken(_))),
"link_sso_ticket 不存在的 token 应返回 InvalidToken"
);
let r2 = session
.link_oauth2_token("nonexistent", "access-token")
.await;
assert!(
matches!(r2, Err(GarrisonError::InvalidToken(_))),
"link_oauth2_token 不存在的 token 应返回 InvalidToken"
);
let r3 = session
.link_temp_credential("nonexistent", "temp-key")
.await;
assert!(
matches!(r3, Err(GarrisonError::InvalidToken(_))),
"link_temp_credential 不存在的 token 应返回 InvalidToken"
);
}
#[tokio::test]
async fn logout_destroys_linked_sso_ticket() {
let (dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let sso_key = "garrison:sso:ticket:ticket-abc-123";
dao.set(sso_key, r#"{"login_id":1001,"client_id":1}"#, 60)
.await
.unwrap();
session
.link_sso_ticket("T1", "ticket-abc-123")
.await
.unwrap();
assert!(dao.get(sso_key).await.unwrap().is_some());
session.logout("T1").await.unwrap();
assert!(
dao.get(sso_key).await.unwrap().is_none(),
"logout 后关联的 SSO ticket 应被删除"
);
assert!(session.get_token_session("T1").await.unwrap().is_none());
}
#[tokio::test]
async fn logout_without_sso_ticket_does_not_affect_sso_keys() {
let (dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let unrelated_sso_key = "garrison:sso:ticket:other-ticket";
dao.set(unrelated_sso_key, r#"{"login_id":2002,"client_id":2}"#, 60)
.await
.unwrap();
session.logout("T1").await.unwrap();
assert!(
dao.get(unrelated_sso_key).await.unwrap().is_some(),
"logout 未关联 SSO ticket 的 token 不应影响其他 SSO keys"
);
}
#[tokio::test]
async fn is_valid_returns_true_when_temp_credential_exists() {
let (dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let temp_key = "garrison:temp:order:abc123";
dao.set(temp_key, "secret-value", 300).await.unwrap();
session.link_temp_credential("T1", temp_key).await.unwrap();
let valid = session.is_valid("T1").await.unwrap();
assert!(valid, "临时凭证存在时 token 应有效");
}
#[tokio::test]
async fn is_valid_returns_false_when_temp_credential_expired() {
let (dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let temp_key = "garrison:temp:order:abc123";
dao.set(temp_key, "secret-value", 300).await.unwrap();
session.link_temp_credential("T1", temp_key).await.unwrap();
dao.delete(temp_key).await.unwrap();
let valid = session.is_valid("T1").await.unwrap();
assert!(
!valid,
"临时凭证过期后 token 应立即失效,不论 token 自身 timeout 是否到期"
);
}
#[tokio::test]
async fn is_valid_returns_true_when_no_temp_credential_linked() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let valid = session.is_valid("T1").await.unwrap();
assert!(valid, "未关联临时凭证时 token 有效性应遵循 0.1.0 既有行为");
}
#[tokio::test]
async fn create_accepts_login_id_numeric() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert_eq!(ts.login_id, "1001");
}
#[tokio::test]
async fn get_account_session_accepts_login_id_numeric() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let as_ = session.get_account_session("1001").await.unwrap().unwrap();
assert_eq!(as_.login_id, "1001");
}
#[tokio::test]
async fn logout_by_login_id_accepts_login_id_numeric() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.logout_by_login_id("1001").await.unwrap();
assert!(session.get_token_session("T1").await.unwrap().is_none());
}
#[tokio::test]
async fn set_device_updates_token_session_device() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.set_device("T1", "web-chrome").await.unwrap();
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert_eq!(ts.device.as_deref(), Some("web-chrome"));
}
#[tokio::test]
async fn set_device_nonexistent_token_errors() {
let (_dao, session) = make_session(3600, 86400);
let result = session.set_device("nonexistent", "web").await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"set_device 不存在的 token 应返回 InvalidToken"
);
}
#[tokio::test]
async fn kickout_by_device_removes_matching_tokens() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.set_device("T1", "web-chrome").await.unwrap();
session.create("1001", "T2").await.unwrap();
session.set_device("T2", "mobile-ios").await.unwrap();
session.create("1001", "T3").await.unwrap();
session.set_device("T3", "web-chrome").await.unwrap();
session
.kickout_by_device("1001", "web-chrome")
.await
.unwrap();
assert!(session.get_token_session("T1").await.unwrap().is_none());
assert!(session.get_token_session("T3").await.unwrap().is_none());
assert!(session.get_token_session("T2").await.unwrap().is_some());
}
#[tokio::test]
async fn kickout_by_device_preserves_other_devices() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.set_device("T1", "web-chrome").await.unwrap();
session.create("1001", "T2").await.unwrap();
session.set_device("T2", "mobile-ios").await.unwrap();
session
.kickout_by_device("1001", "web-chrome")
.await
.unwrap();
assert!(session.is_valid("T2").await.unwrap());
}
#[tokio::test]
async fn kickout_by_device_nonexistent_device_is_noop() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.set_device("T1", "web-chrome").await.unwrap();
let result = session
.kickout_by_device("1001", "nonexistent-device")
.await;
assert!(result.is_ok());
assert!(session.get_token_session("T1").await.unwrap().is_some());
}
#[tokio::test]
async fn kickout_by_device_no_account_session_is_noop() {
let (_dao, session) = make_session(3600, 86400);
let result = session.kickout_by_device("9999", "web-chrome").await;
assert!(result.is_ok());
}
#[tokio::test]
async fn kickout_by_device_updates_account_session_tokens() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.set_device("T1", "web-chrome").await.unwrap();
session.create("1001", "T2").await.unwrap();
session.set_device("T2", "mobile-ios").await.unwrap();
session
.kickout_by_device("1001", "web-chrome")
.await
.unwrap();
let account = session.get_account_session("1001").await.unwrap().unwrap();
assert_eq!(account.tokens.len(), 1, "account session 应只剩 1 个 token");
assert_eq!(account.tokens[0].token, "T2", "剩余 token 应为 T2");
}
#[tokio::test]
async fn kickout_by_device_accepts_login_id_numeric() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.set_device("T1", "web-chrome").await.unwrap();
session
.kickout_by_device("1001", "web-chrome")
.await
.unwrap();
assert!(session.get_token_session("T1").await.unwrap().is_none());
}
#[cfg(feature = "listener")]
#[tokio::test]
async fn kickout_by_device_broadcasts_kickout_events() {
use crate::listener::GarrisonListenerManager;
let mgr = Arc::new(GarrisonListenerManager::new());
let (_dao, session) = make_session(3600, 86400);
let session = session.with_listener_manager(mgr);
session.create("1001", "T1").await.unwrap();
session.set_device("T1", "web-chrome").await.unwrap();
let result = session.kickout_by_device("1001", "web-chrome").await;
assert!(result.is_ok());
assert!(session.get_token_session("T1").await.unwrap().is_none());
}
#[cfg(feature = "listener")]
#[test]
fn with_listener_manager_sets_field() {
use crate::listener::GarrisonListenerManager;
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let mgr = Arc::new(GarrisonListenerManager::new());
let session = GarrisonSession::new(dao, 3600, 86400, 0).with_listener_manager(mgr);
assert!(session.listener_manager.is_some());
}
struct FailingDeleteDao {
inner: Arc<MockDao>,
fail_delete_key: String,
}
#[async_trait]
impl GarrisonDao for FailingDeleteDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
self.inner.get(key).await
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
self.inner.set(key, value, ttl_seconds).await
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
self.inner.update(key, value).await
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
self.inner.expire(key, seconds).await
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
if key == self.fail_delete_key {
return Err(GarrisonError::Dao("session-mock-delete-failed".to_string()));
}
self.inner.delete(key).await
}
crate::atomic_test_fallback!();
}
#[tokio::test]
async fn logout_sso_ticket_delete_failure_logs_warn_without_failing() {
let inner = Arc::new(MockDao::new());
{
let d = FailingDeleteDao {
inner: inner.clone(),
fail_delete_key: "x".to_string(),
};
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.keys("*").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(FailingDeleteDao {
inner: inner.clone(),
fail_delete_key: "garrison:sso:ticket:ticket-fail".to_string(),
});
let session = GarrisonSession::new(dao, 3600, 86400, 0);
session.create("1001", "T1").await.unwrap();
session.link_sso_ticket("T1", "ticket-fail").await.unwrap();
let result = session.logout("T1").await;
assert!(
result.is_ok(),
"logout 不应因 SSO ticket 删除失败而中断: {:?}",
result
);
let ts = session.get_token_session("T1").await.unwrap();
assert!(ts.is_none(), "logout 后 Token-Session 应已删除");
}
async fn expire_token_session_in_dao(dao: &Arc<MockDao>, token: &str, timeout: u64) {
let key = token_key(token);
let json = dao.get(&key).await.unwrap().unwrap();
let mut ts: TokenSession = serde_json::from_str(&json).unwrap();
ts.last_active_at = Utc::now().timestamp() - timeout as i64 - 1;
let new_json = serde_json::to_string(&ts).unwrap();
dao.set(&key, &new_json, 3600).await.unwrap();
}
async fn expire_account_session_in_dao(
dao: &Arc<MockDao>,
login_id: &str,
active_timeout: u64,
) {
let key = account_key(login_id);
let json = dao.get(&key).await.unwrap().unwrap();
let mut as_: AccountSession = serde_json::from_str(&json).unwrap();
as_.last_active_at = Utc::now().timestamp() - active_timeout as i64 - 1;
let new_json = serde_json::to_string(&as_).unwrap();
dao.set(&key, &new_json, 3600).await.unwrap();
}
#[tokio::test]
async fn add_expiry_listener_registers_listener() {
let (_dao, mut session) = make_session(3600, 86400);
assert!(session.expiry_listeners.is_empty());
let (listener, _) = MockExpiryListener::new();
session.add_expiry_listener(Arc::new(listener));
assert_eq!(session.expiry_listeners.len(), 1);
}
#[tokio::test]
async fn get_token_session_triggers_callback_on_expiry() {
let (dao, mut session) = make_session(3600, 86400);
let (listener, calls) = MockExpiryListener::new();
session.add_expiry_listener(Arc::new(listener));
session.create("1001", "T1").await.unwrap();
expire_token_session_in_dao(&dao, "T1", 3600).await;
let result = session.get_token_session("T1").await.unwrap();
assert!(result.is_none(), "过期 session 应返回 None");
let recorded = calls.lock().unwrap();
assert_eq!(recorded.len(), 1, "应触发 1 次回调");
assert_eq!(recorded[0].0, "1001");
assert_eq!(recorded[0].1, "T1");
}
#[tokio::test]
async fn get_token_session_no_callback_for_active_session() {
let (_dao, mut session) = make_session(3600, 86400);
let (listener, calls) = MockExpiryListener::new();
session.add_expiry_listener(Arc::new(listener));
session.create("1001", "T1").await.unwrap();
let result = session.get_token_session("T1").await.unwrap();
assert!(result.is_some());
assert!(
calls.lock().unwrap().is_empty(),
"未过期 session 不应触发回调"
);
}
#[tokio::test]
async fn get_token_session_deletes_expired_session_after_callback() {
let (dao, mut session) = make_session(3600, 86400);
let (listener, _calls) = MockExpiryListener::new();
session.add_expiry_listener(Arc::new(listener));
session.create("1001", "T1").await.unwrap();
expire_token_session_in_dao(&dao, "T1", 3600).await;
assert!(dao.get(&token_key("T1")).await.unwrap().is_some());
session.get_token_session("T1").await.unwrap();
assert!(
dao.get(&token_key("T1")).await.unwrap().is_none(),
"过期 session 应从 DAO 删除"
);
}
#[tokio::test]
async fn get_account_session_triggers_callback_on_expiry() {
let (dao, mut session) = make_session(3600, 3600);
let (listener, calls) = MockExpiryListener::new();
session.add_expiry_listener(Arc::new(listener));
session.create("1001", "T1").await.unwrap();
expire_account_session_in_dao(&dao, "1001", 3600).await;
let result = session.get_account_session("1001").await.unwrap();
assert!(result.is_none(), "过期 account session 应返回 None");
let recorded = calls.lock().unwrap();
assert_eq!(recorded.len(), 1, "应触发 1 次回调");
assert_eq!(recorded[0].0, "1001");
assert_eq!(
recorded[0].1, "",
"Account-Session 级过期 token 应为空字符串"
);
}
#[tokio::test]
async fn get_account_session_no_callback_for_active_session() {
let (_dao, mut session) = make_session(3600, 86400);
let (listener, calls) = MockExpiryListener::new();
session.add_expiry_listener(Arc::new(listener));
session.create("1001", "T1").await.unwrap();
let result = session.get_account_session("1001").await.unwrap();
assert!(result.is_some());
assert!(
calls.lock().unwrap().is_empty(),
"未过期 session 不应触发回调"
);
}
#[tokio::test]
async fn multiple_listeners_called_in_fifo_order() {
let (dao, mut session) = make_session(3600, 86400);
let (listener1, calls1) = MockExpiryListener::new();
let (listener2, calls2) = MockExpiryListener::new();
session.add_expiry_listener(Arc::new(listener1));
session.add_expiry_listener(Arc::new(listener2));
session.create("1001", "T1").await.unwrap();
expire_token_session_in_dao(&dao, "T1", 3600).await;
session.get_token_session("T1").await.unwrap();
assert_eq!(calls1.lock().unwrap().len(), 1);
assert_eq!(calls2.lock().unwrap().len(), 1);
}
#[tokio::test]
async fn failing_listener_does_not_interrupt_subsequent_listeners() {
let (dao, mut session) = make_session(3600, 86400);
let failing = MockExpiryListener::new_failing();
let (success, calls) = MockExpiryListener::new();
session.add_expiry_listener(Arc::new(failing));
session.add_expiry_listener(Arc::new(success));
session.create("1001", "T1").await.unwrap();
expire_token_session_in_dao(&dao, "T1", 3600).await;
let result = session.get_token_session("T1").await.unwrap();
assert!(result.is_none(), "过期 session 应返回 None");
assert_eq!(
calls.lock().unwrap().len(),
1,
"失败的 listener 不应阻止后续 listener 执行"
);
}
#[tokio::test]
async fn expired_session_with_no_listeners_still_deleted() {
let (dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
expire_token_session_in_dao(&dao, "T1", 3600).await;
let result = session.get_token_session("T1").await.unwrap();
assert!(result.is_none());
assert!(
dao.get(&token_key("T1")).await.unwrap().is_none(),
"无 listener 时过期 session 仍应从 DAO 删除"
);
}
struct SlowDao {
inner: Arc<MockDao>,
delay: Duration,
}
#[async_trait]
impl GarrisonDao for SlowDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
let result = self.inner.get(key).await;
if key.starts_with("account:session:") {
tokio::time::sleep(self.delay).await;
}
result
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
self.inner.set(key, value, ttl_seconds).await
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
self.inner.update(key, value).await
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
self.inner.expire(key, seconds).await
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
self.inner.delete(key).await
}
crate::atomic_test_fallback!();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[serial_test::serial]
async fn concurrent_login_same_user_creates_consistent_session() {
let inner = Arc::new(MockDao::new());
{
let d = SlowDao {
inner: inner.clone(),
delay: Duration::from_millis(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.keys("*").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(SlowDao {
inner: inner.clone(),
delay: Duration::from_millis(50),
});
let session = GarrisonSession::new(dao, 3600, 86400, 0);
let (r1, r2) = tokio::join!(session.create("1001", "T1"), session.create("1001", "T2"),);
r1.expect("create T1 应成功");
r2.expect("create T2 应成功");
let account = session
.get_account_session("1001")
.await
.expect("get_account_session 应成功")
.expect("Account-Session 应存在");
assert_eq!(
account.tokens.len(),
2,
"并发 create 后 Account-Session 应包含 2 个 token(修复前 lost update 导致只剩 1 个)"
);
assert!(
session.is_valid("T1").await.expect("is_valid T1 应成功"),
"T1 应有效"
);
assert!(
session.is_valid("T2").await.expect("is_valid T2 应成功"),
"T2 应有效"
);
}
#[test]
fn check_hover_timeout_disabled_when_negative() {
let (_dao, session) = make_session(3600, 86400);
session.update_last_active("user1");
assert!(
session.check_hover_timeout("user1", -1),
"hover_timeout=-1 时应始终返回 true(不启用)"
);
}
#[test]
fn check_hover_timeout_disabled_when_zero() {
let (_dao, session) = make_session(3600, 86400);
session.update_last_active("user1");
assert!(
session.check_hover_timeout("user1", 0),
"hover_timeout=0 时应始终返回 true(不启用)"
);
}
#[test]
fn check_hover_timeout_returns_true_when_no_record() {
let (_dao, session) = make_session(3600, 86400);
assert!(
session.check_hover_timeout("nonexistent", 10),
"无记录时应返回 true(首次 check_login 不踢出)"
);
}
#[test]
fn check_hover_timeout_returns_true_when_active() {
let (_dao, session) = make_session(3600, 86400);
session.update_last_active("user1");
assert!(
session.check_hover_timeout("user1", 10),
"活跃会话应返回 true"
);
}
#[test]
fn check_hover_timeout_evicts_after_timeout() {
let (_dao, session) = make_session(3600, 86400);
let old_time = chrono::Utc::now().timestamp_millis() - 5000;
session
.last_active_time
.insert("user1".to_string(), old_time);
assert!(
!session.check_hover_timeout("user1", 1),
"悬停超时后应返回 false(踢出)"
);
}
#[test]
fn update_and_get_last_active_roundtrip() {
let (_dao, session) = make_session(3600, 86400);
assert!(
session.get_last_active("user1").is_none(),
"未更新前应返回 None"
);
session.update_last_active("user1");
let ts = session.get_last_active("user1");
assert!(ts.is_some(), "更新后应返回 Some");
let now = chrono::Utc::now().timestamp_millis();
assert!(
(now - ts.unwrap()).abs() < 1000,
"last_active_time 应接近当前时间"
);
}
#[tokio::test]
async fn token_session_stores_ip_and_user_agent() {
let (_dao, session) = make_session(3600, 86400);
let params = LoginParams {
device: Some("web-chrome".to_string()),
ip: Some("192.168.1.100".to_string()),
user_agent: Some("Mozilla/5.0".to_string()),
remember_me: false,
require_mfa: false,
};
session
.create_token_session("1001", "T1", ¶ms)
.await
.unwrap();
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert_eq!(ts.device.as_deref(), Some("web-chrome"));
assert_eq!(ts.ip.as_deref(), Some("192.168.1.100"));
assert_eq!(ts.user_agent.as_deref(), Some("Mozilla/5.0"));
}
#[tokio::test]
async fn token_session_defaults_to_none_when_no_params() {
let (_dao, session) = make_session(3600, 86400);
session
.create_token_session("1001", "T1", &LoginParams::default())
.await
.unwrap();
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert!(ts.device.is_none(), "device 应为 None");
assert!(ts.ip.is_none(), "ip 应为 None");
assert!(ts.user_agent.is_none(), "user_agent 应为 None");
}
#[test]
fn login_token_map_tracks_multiple_tokens() {
let (_dao, session) = make_session(3600, 86400);
session.add_login_token("user1", "token1");
session.add_login_token("user1", "token2");
let tokens = session.get_tokens_by_login_id("user1");
assert_eq!(
tokens,
vec!["token1".to_string(), "token2".to_string()],
"应按添加顺序返回两个 token"
);
}
#[test]
fn get_token_by_login_id_returns_first() {
let (_dao, session) = make_session(3600, 86400);
session.add_login_token("user2", "tokenA");
session.add_login_token("user2", "tokenB");
let first = session.get_token_by_login_id("user2");
assert_eq!(
first,
Some("tokenA".to_string()),
"应返回第一个添加的 token"
);
}
#[test]
fn kickout_cleans_login_token_map() {
let (_dao, session) = make_session(3600, 86400);
session.add_login_token("user3", "tokenX");
session.remove_login_token("user3", "tokenX");
let tokens = session.get_tokens_by_login_id("user3");
assert!(tokens.is_empty(), "移除后应返回空列表");
assert!(
session.get_token_by_login_id("user3").is_none(),
"entry 已移除,应返回 None"
);
}
#[tokio::test]
async fn cleanup_expired_tokens_no_tokens_returns_zero() {
let (_dao, session) = make_session(3600, 86400);
let removed = session.cleanup_expired_tokens().await.unwrap();
assert_eq!(removed, 0, "无 token 时应返回 0");
}
#[tokio::test]
async fn cleanup_expired_tokens_removes_expired() {
let (dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
expire_token_session_in_dao(&dao, "T1", 3600).await;
let removed = session.cleanup_expired_tokens().await.unwrap();
assert_eq!(removed, 1, "应清理 1 个过期 token");
assert!(
session.get_token_by_login_id("1001").is_none(),
"清理后 login_id entry 应被移除"
);
}
#[tokio::test]
async fn cleanup_expired_tokens_removes_logged_out() {
let (dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
dao.delete(&token_key("T1")).await.unwrap();
let removed = session.cleanup_expired_tokens().await.unwrap();
assert_eq!(removed, 1, "应清理 1 个已注销 token");
assert!(
session.get_token_by_login_id("1001").is_none(),
"清理后 login_id entry 应被移除"
);
}
#[tokio::test]
async fn cleanup_expired_tokens_keeps_valid() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let removed = session.cleanup_expired_tokens().await.unwrap();
assert_eq!(removed, 0, "有效 token 不应被清理");
let tokens = session.get_tokens_by_login_id("1001");
assert_eq!(tokens, vec!["T1".to_string()], "有效 token 应保留");
assert!(session.get_token_session("T1").await.unwrap().is_some());
}
#[tokio::test]
async fn cleanup_expired_tokens_multi_login_id_mixed() {
let (dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.create("2002", "T2").await.unwrap();
expire_token_session_in_dao(&dao, "T1", 3600).await;
let removed = session.cleanup_expired_tokens().await.unwrap();
assert_eq!(removed, 1, "应清理 1 个过期 token");
assert!(
session.get_token_by_login_id("1001").is_none(),
"1001 的 entry 应被移除"
);
let tokens = session.get_tokens_by_login_id("2002");
assert_eq!(tokens, vec!["T2".to_string()], "2002 的有效 token 应保留");
}
#[tokio::test]
async fn cleanup_expired_tokens_all_expired_cleans_all() {
let (dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.create("1001", "T2").await.unwrap();
expire_token_session_in_dao(&dao, "T1", 3600).await;
expire_token_session_in_dao(&dao, "T2", 3600).await;
let removed = session.cleanup_expired_tokens().await.unwrap();
assert_eq!(removed, 2, "应清理 2 个过期 token");
assert!(
session.get_token_by_login_id("1001").is_none(),
"全部清理后 entry 应被移除"
);
}
#[tokio::test]
async fn cleanup_expired_tokens_partial_expired() {
let (dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.create("1001", "T2").await.unwrap();
expire_token_session_in_dao(&dao, "T1", 3600).await;
let removed = session.cleanup_expired_tokens().await.unwrap();
assert_eq!(removed, 1, "应清理 1 个过期 token");
let tokens = session.get_tokens_by_login_id("1001");
assert_eq!(tokens, vec!["T2".to_string()], "应只剩有效的 T2");
}
#[tokio::test]
async fn cleanup_expired_tokens_returns_correct_count() {
let (dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.create("1001", "T2").await.unwrap();
session.create("2002", "T3").await.unwrap();
session.create("2002", "T4").await.unwrap();
expire_token_session_in_dao(&dao, "T1", 3600).await;
expire_token_session_in_dao(&dao, "T3", 3600).await;
let removed = session.cleanup_expired_tokens().await.unwrap();
assert_eq!(removed, 2, "应清理 2 个过期 token(T1 + T3)");
let tokens_1001 = session.get_tokens_by_login_id("1001");
assert_eq!(tokens_1001, vec!["T2".to_string()]);
let tokens_2002 = session.get_tokens_by_login_id("2002");
assert_eq!(tokens_2002, vec!["T4".to_string()]);
}
struct FailingGetDao {
inner: Arc<MockDao>,
fail_get_key: String,
}
#[async_trait]
impl GarrisonDao for FailingGetDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
if key == self.fail_get_key {
return Err(GarrisonError::Dao("session-mock-read-failed".to_string()));
}
self.inner.get(key).await
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
self.inner.set(key, value, ttl_seconds).await
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
self.inner.update(key, value).await
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
self.inner.expire(key, seconds).await
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
self.inner.delete(key).await
}
crate::atomic_test_fallback!();
}
#[cfg(feature = "session-extra")]
struct FailingUpdateDao {
inner: Arc<MockDao>,
fail_update_key: String,
}
#[cfg(feature = "session-extra")]
#[async_trait]
impl GarrisonDao for FailingUpdateDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
self.inner.get(key).await
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
self.inner.set(key, value, ttl_seconds).await
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
if key == self.fail_update_key {
return Err(GarrisonError::Dao("session-mock-update-failed".to_string()));
}
self.inner.update(key, value).await
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
self.inner.expire(key, seconds).await
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
self.inner.delete(key).await
}
crate::atomic_test_fallback!();
}
#[tokio::test]
async fn cleanup_expired_tokens_dao_failure_skips_token_without_aborting() {
let inner = Arc::new(MockDao::new());
{
let d = FailingGetDao {
inner: inner.clone(),
fail_get_key: "x".to_string(),
};
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.keys("*").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 {
inner: inner.clone(),
fail_get_key: token_key("T2"),
});
let session = GarrisonSession::new(dao, 3600, 86400, 0);
session.create("1001", "T1").await.unwrap();
session.create("1001", "T2").await.unwrap();
session.create("1001", "T3").await.unwrap();
inner.delete(&token_key("T3")).await.unwrap();
let removed = session.cleanup_expired_tokens().await.unwrap();
assert_eq!(
removed, 1,
"应只清理 1 个已注销 token(T3),T2 因 DAO 失败被跳过"
);
let tokens = session.get_tokens_by_login_id("1001");
assert!(tokens.contains(&"T1".to_string()), "T1(有效)应保留");
assert!(
tokens.contains(&"T2".to_string()),
"T2(DAO 失败被跳过)应保留在 map 中"
);
assert!(!tokens.contains(&"T3".to_string()), "T3(已注销)应被清理");
}
#[cfg(feature = "session-extra")]
#[tokio::test]
async fn token_session_dynamic_active_timeout_defaults_to_none() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert!(
ts.dynamic_active_timeout.is_none(),
"新创建的 TokenSession 的 dynamic_active_timeout 应默认为 None"
);
}
#[cfg(feature = "session-extra")]
#[tokio::test]
async fn set_active_timeout_sets_dynamic_timeout() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert!(ts.dynamic_active_timeout.is_none());
session.set_active_timeout("T1", 600).await.unwrap();
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert_eq!(
ts.dynamic_active_timeout,
Some(600),
"set_active_timeout 后 dynamic_active_timeout 应为 Some(600)"
);
}
#[cfg(feature = "session-extra")]
#[tokio::test]
async fn set_active_timeout_returns_error_for_nonexistent_token() {
let (_dao, session) = make_session(3600, 86400);
let result = session.set_active_timeout("nonexistent", 600).await;
assert!(
result.is_err(),
"set_active_timeout 对不存在的 token 应返回 Err"
);
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"set_active_timeout 对不存在的 token 应返回 InvalidToken 错误,实际: {:?}",
result
);
}
#[cfg(feature = "session-extra")]
#[tokio::test]
async fn set_active_timeout_zero_returns_invalid_param() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let result = session.set_active_timeout("T1", 0).await;
assert!(
matches!(result, Err(GarrisonError::InvalidParam(_))),
"timeout_secs=0 应返回 InvalidParam,实际: {:?}",
result
);
}
#[cfg(feature = "session-extra")]
#[tokio::test]
async fn set_active_timeout_negative_one_means_never_expire() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
session.set_active_timeout("T1", -1).await.unwrap();
let valid = session.is_valid("T1").await.unwrap();
assert!(
valid,
"dynamic_active_timeout=-1 表示永不过期,is_valid 应返回 true"
);
}
#[cfg(feature = "session-extra")]
#[tokio::test]
async fn rebuild_login_token_map_empty_dao_produces_empty_map() {
let (_dao, session) = make_session(3600, 86400);
session.rebuild_login_token_map().await.unwrap();
assert!(
session.login_token_map.is_empty(),
"空 DAO 重建后 login_token_map 应为空"
);
}
#[cfg(feature = "session-extra")]
#[tokio::test]
async fn rebuild_login_token_map_with_3_sessions_populates_all_tokens() {
let (_dao, session) = make_session(3600, 86400);
session.create("user1", "T1").await.unwrap();
session.create("user1", "T2").await.unwrap();
session.create("user2", "T3").await.unwrap();
session.create("user2", "T4").await.unwrap();
session.create("user3", "T5").await.unwrap();
session.create("user3", "T6").await.unwrap();
session.login_token_map.clear();
assert!(session.login_token_map.is_empty());
session.rebuild_login_token_map().await.unwrap();
assert_eq!(
session.login_token_map.len(),
3,
"应重建 3 个 login_id entry"
);
let tokens1 = session.get_tokens_by_login_id("user1");
assert_eq!(tokens1.len(), 2, "user1 应有 2 个 token");
assert!(tokens1.contains(&"T1".to_string()));
assert!(tokens1.contains(&"T2".to_string()));
let tokens2 = session.get_tokens_by_login_id("user2");
assert_eq!(tokens2.len(), 2, "user2 应有 2 个 token");
assert!(tokens2.contains(&"T3".to_string()));
assert!(tokens2.contains(&"T4".to_string()));
let tokens3 = session.get_tokens_by_login_id("user3");
assert_eq!(tokens3.len(), 2, "user3 应有 2 个 token");
assert!(tokens3.contains(&"T5".to_string()));
assert!(tokens3.contains(&"T6".to_string()));
}
#[cfg(feature = "session-extra")]
#[tokio::test]
async fn add_login_token_persistent_adds_to_both_layers() {
let (_dao, session) = make_session(3600, 86400);
session.create("user1", "T1").await.unwrap();
session
.add_login_token_persistent("user1", "T2")
.await
.unwrap();
let account = session.get_account_session("user1").await.unwrap().unwrap();
let dao_tokens: Vec<String> = account.tokens.into_iter().map(|ti| ti.token).collect();
assert_eq!(
dao_tokens.len(),
2,
"DAO AccountSession.tokens 应有 2 个 token"
);
assert!(dao_tokens.contains(&"T1".to_string()));
assert!(dao_tokens.contains(&"T2".to_string()));
let mem_tokens = session.get_tokens_by_login_id("user1");
assert_eq!(mem_tokens.len(), 2, "内存 login_token_map 应有 2 个 token");
assert!(mem_tokens.contains(&"T1".to_string()));
assert!(mem_tokens.contains(&"T2".to_string()));
}
#[cfg(feature = "session-extra")]
#[tokio::test]
async fn remove_login_token_persistent_removes_from_both_layers() {
let (_dao, session) = make_session(3600, 86400);
session.create("user1", "T1").await.unwrap();
session.create("user1", "T2").await.unwrap();
session
.remove_login_token_persistent("user1", "T1")
.await
.unwrap();
let account = session.get_account_session("user1").await.unwrap().unwrap();
let dao_tokens: Vec<String> = account.tokens.into_iter().map(|ti| ti.token).collect();
assert_eq!(
dao_tokens.len(),
1,
"DAO AccountSession.tokens 应剩 1 个 token"
);
assert!(!dao_tokens.contains(&"T1".to_string()));
assert!(dao_tokens.contains(&"T2".to_string()));
let mem_tokens = session.get_tokens_by_login_id("user1");
assert_eq!(mem_tokens.len(), 1, "内存 login_token_map 应剩 1 个 token");
assert!(!mem_tokens.contains(&"T1".to_string()));
assert!(mem_tokens.contains(&"T2".to_string()));
}
#[cfg(feature = "session-extra")]
#[tokio::test]
async fn add_login_token_persistent_dao_failure_skips_memory_write() {
let inner = Arc::new(MockDao::new());
let dao: Arc<dyn GarrisonDao> = Arc::new(FailingUpdateDao {
inner: inner.clone(),
fail_update_key: account_key("user1"),
});
let session = GarrisonSession::new(dao, 3600, 86400, 0);
session.create("user1", "T1").await.unwrap();
session.login_token_map.clear();
let result = session.add_login_token_persistent("user1", "T2").await;
assert!(
result.is_err(),
"DAO update 失败时应返回 Err,实际: {:?}",
result
);
let mem_tokens = session.get_tokens_by_login_id("user1");
assert!(
mem_tokens.is_empty(),
"DAO 失败时内存不应写入,实际: {:?}",
mem_tokens
);
}
#[cfg(feature = "session-extra")]
#[tokio::test]
async fn login_logout_persistent_consistency() {
let (_dao, session) = make_session(3600, 86400);
session.create("user1", "T1").await.unwrap();
let account = session.get_account_session("user1").await.unwrap().unwrap();
let dao_tokens: Vec<String> = account.tokens.into_iter().map(|ti| ti.token).collect();
assert_eq!(
dao_tokens.len(),
1,
"DAO AccountSession.tokens 应有 1 个 token"
);
assert!(dao_tokens.contains(&"T1".to_string()));
let mem_tokens = session.get_tokens_by_login_id("user1");
assert_eq!(mem_tokens.len(), 1, "内存 login_token_map 应有 1 个 token");
assert!(mem_tokens.contains(&"T1".to_string()));
session.logout("T1").await.unwrap();
let account = session.get_account_session("user1").await.unwrap().unwrap();
let dao_tokens: Vec<String> = account.tokens.into_iter().map(|ti| ti.token).collect();
assert!(
dao_tokens.is_empty(),
"logout 后 DAO AccountSession.tokens 应为空,实际: {:?}",
dao_tokens
);
let mem_tokens = session.get_tokens_by_login_id("user1");
assert!(
mem_tokens.is_empty(),
"logout 后内存 login_token_map 不应包含 T1,实际: {:?}",
mem_tokens
);
}
#[tokio::test]
async fn create_seeds_pwd_ledger_and_auth_time() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert_eq!(ts.amr_ledger.len(), 1, "登录会话应播种 1 条主因子账本");
assert_eq!(ts.amr_ledger[0].method, "pwd");
assert_eq!(ts.amr_ledger[0].aal, 1);
assert_eq!(ts.amr_ledger[0].completed_at, ts.created_at);
assert_eq!(
ts.auth_time,
Some(ts.created_at),
"auth_time 应等于登录时刻"
);
}
#[tokio::test]
async fn append_amr_entry_extends_ledger_keeps_auth_time() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let seeded_auth_time = session
.get_token_session("T1")
.await
.unwrap()
.unwrap()
.auth_time
.unwrap();
let later = Utc::now().timestamp() + 30;
session
.append_amr_entry("T1", "otp", 2, later)
.await
.unwrap();
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert_eq!(ts.amr_ledger.len(), 2);
assert_eq!(ts.amr_ledger[1].method, "otp");
assert_eq!(ts.amr_ledger[1].aal, 2);
assert_eq!(ts.amr_ledger[1].completed_at, later);
assert_eq!(
ts.auth_time,
Some(seeded_auth_time),
"step-up 不应移动 auth_time"
);
}
#[tokio::test]
async fn append_amr_entry_rejects_unknown_method() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
let result = session.append_amr_entry("T1", "sms", 2, 0).await;
assert!(
matches!(result, Err(GarrisonError::InvalidParam(ref m)) if m.contains("amr-method")),
"未知 amr method 应返回 InvalidParam,实际: {:?}",
result
);
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert_eq!(ts.amr_ledger.len(), 1, "非法条目不得入账");
}
#[tokio::test]
async fn append_amr_entry_rejects_out_of_range_aal() {
let (_dao, session) = make_session(3600, 86400);
session.create("1001", "T1").await.unwrap();
for aal in [0u8, 4] {
let result = session.append_amr_entry("T1", "otp", aal, 0).await;
assert!(
matches!(result, Err(GarrisonError::InvalidParam(ref m)) if m.contains("aal")),
"aal={} 应返回 InvalidParam,实际: {:?}",
aal,
result
);
}
}
#[tokio::test]
async fn append_amr_entry_nonexistent_token_errors() {
let (_dao, session) = make_session(3600, 86400);
let result = session.append_amr_entry("nonexistent", "otp", 2, 0).await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"不存在的 token 应返回 InvalidToken,实际: {:?}",
result
);
}
#[test]
fn token_session_without_ledger_fields_deserializes_with_defaults() {
let json = serde_json::json!({
"token": "T1",
"login_id": "1001",
"created_at": 1700000000i64,
"last_active_at": 1700000000i64,
"attrs": {}
});
let ts: TokenSession = serde_json::from_value(json).unwrap();
assert!(ts.amr_ledger.is_empty(), "缺失账本字段应默认为空");
assert_eq!(ts.auth_time, None, "缺失 auth_time 应默认为 None");
}
}