use super::current_token;
use super::GarrisonLogicDefault;
use crate::error::{GarrisonError, GarrisonResult};
impl GarrisonLogicDefault {
pub async fn open_safe(&self, service: &str, duration_secs: u64) -> GarrisonResult<()> {
if service.is_empty() {
return Err(GarrisonError::InvalidParam(
"stp-service-empty::".to_string(),
));
}
let token = current_token()?;
let token_prefix = if token.len() >= 8 {
&token[..8]
} else {
&token
};
let service = service.to_string();
self.session
.with_token_session_lock(&token, async {
let mut ts = self
.session
.get_token_session(&token)
.await?
.ok_or_else(|| {
GarrisonError::InvalidToken(format!(
"stp-token-not-found::{}",
token_prefix
))
})?;
let now = chrono::Utc::now().timestamp();
let expire_at = now + duration_secs as i64;
ts.safe_services.insert(service.clone(), expire_at);
self.session.save_token_session(&token, &ts).await
})
.await
}
pub async fn is_safe(&self, service: &str) -> GarrisonResult<bool> {
if service.is_empty() {
return Err(GarrisonError::InvalidParam(
"stp-service-empty::".to_string(),
));
}
let token = match current_token() {
Ok(t) => t,
Err(_) => return Ok(false),
};
let ts = match self.session.get_token_session(&token).await? {
Some(ts) => ts,
None => return Ok(false),
};
let now = chrono::Utc::now().timestamp();
match ts.safe_services.get(service) {
Some(expire_at) if *expire_at > now => Ok(true),
Some(_) => {
drop(ts);
let service_owned = service.to_string();
let _ = self
.session
.with_token_session_lock(&token, async {
let mut ts = match self.session.get_token_session(&token).await? {
Some(ts) => ts,
None => return Ok(()),
};
let now = chrono::Utc::now().timestamp();
if ts
.safe_services
.get(&service_owned)
.is_some_and(|e| *e <= now)
{
ts.safe_services.remove(&service_owned);
self.session.save_token_session(&token, &ts).await?;
}
Ok::<(), GarrisonError>(())
})
.await;
Ok(false)
},
None => Ok(false),
}
}
pub async fn close_safe(&self, service: &str) -> GarrisonResult<()> {
if service.is_empty() {
return Err(GarrisonError::InvalidParam(
"stp-service-empty::".to_string(),
));
}
let token = current_token()?;
let token_prefix = if token.len() >= 8 {
&token[..8]
} else {
&token
};
let service = service.to_string();
self.session
.with_token_session_lock(&token, async {
let mut ts = self
.session
.get_token_session(&token)
.await?
.ok_or_else(|| {
GarrisonError::InvalidToken(format!(
"stp-token-not-found::{}",
token_prefix
))
})?;
ts.safe_services.remove(&service);
self.session.save_token_session(&token, &ts).await
})
.await
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::GarrisonConfig;
use crate::dao::tests::MockDao;
use crate::dao::GarrisonDao;
use crate::error::GarrisonError;
use crate::session::GarrisonSession;
use crate::stp::session::SessionLogic;
use crate::stp::with_current_token;
use crate::stp::LoginParams;
use crate::strategy::GarrisonPermissionStrategy;
use async_trait::async_trait;
use std::sync::Arc;
struct MockFirewall;
#[async_trait]
impl GarrisonPermissionStrategy for MockFirewall {
async fn get_permission_list(&self, _login_id: &str) -> GarrisonResult<Vec<String>> {
Ok(vec![])
}
async fn get_role_list(&self, _login_id: &str) -> GarrisonResult<Vec<String>> {
Ok(vec![])
}
async fn check_permission(
&self,
_login_id: &str,
_permission: &str,
) -> GarrisonResult<bool> {
Ok(true)
}
async fn check_role(&self, _login_id: &str, _role: &str) -> GarrisonResult<bool> {
Ok(true)
}
async fn check_role_any(&self, _login_id: &str, _roles: &[&str]) -> GarrisonResult<bool> {
Ok(true)
}
async fn check_role_all(&self, _login_id: &str, _roles: &[&str]) -> GarrisonResult<bool> {
Ok(true)
}
async fn check_permission_in_tenant(
&self,
_tenant_id: i64,
_login_id: &str,
_permission: &str,
) -> GarrisonResult<bool> {
Ok(true)
}
async fn check_role_in_tenant(
&self,
_tenant_id: i64,
_login_id: &str,
_role: &str,
) -> GarrisonResult<bool> {
Ok(true)
}
#[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: &crate::strategy::hooks::LoginContext,
) -> GarrisonResult<()> {
Ok(())
}
}
fn make_logic() -> (GarrisonLogicDefault, Arc<MockDao>) {
let dao = Arc::new(MockDao::new());
let session = Arc::new(GarrisonSession::new(
dao.clone() as Arc<dyn GarrisonDao>,
3600,
86400,
0,
));
let mut config = GarrisonConfig::default_config();
config.throw_on_not_login = false;
config.token_style = "uuid".to_string();
let firewall: Arc<dyn GarrisonPermissionStrategy> = Arc::new(MockFirewall);
let logic = GarrisonLogicDefault::new(
session,
Arc::new(config),
firewall,
Arc::new(crate::account::disable::DefaultDisableRepository::new(
dao.clone(),
)),
);
(logic, dao)
}
#[tokio::test]
async fn t022_open_safe_sets_safe_marker() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-1001", &LoginParams::default())
.await
.unwrap();
with_current_token(token.clone(), async {
logic.open_safe("default", 3600).await.unwrap();
})
.await;
let ts = logic
.session
.get_token_session(&token)
.await
.unwrap()
.unwrap();
let expire = ts
.safe_services
.get("default")
.expect("default 应在 safe_services 中");
let now = chrono::Utc::now().timestamp();
assert!(
*expire > now,
"过期时间应在未来,实际: expire={}, now={}",
expire,
now
);
assert!(
*expire <= now + 3601,
"过期时间应在 now+3600 附近,实际: expire={}, now={}",
expire,
now
);
}
#[tokio::test]
async fn t022_open_safe_multiple_services_coexist() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-1002", &LoginParams::default())
.await
.unwrap();
with_current_token(token.clone(), async {
logic.open_safe("default", 3600).await.unwrap();
logic.open_safe("payment", 7200).await.unwrap();
})
.await;
let ts = logic
.session
.get_token_session(&token)
.await
.unwrap()
.unwrap();
assert_eq!(
ts.safe_services.len(),
2,
"应有 2 个 service 标记,实际: {:?}",
ts.safe_services
);
let default_expire = ts.safe_services.get("default").expect("default 应存在");
let payment_expire = ts.safe_services.get("payment").expect("payment 应存在");
let now = chrono::Utc::now().timestamp();
assert!(
*default_expire > now && *default_expire <= now + 3601,
"default 过期时间应在 now+3600 附近,实际: {}, now={}",
default_expire,
now
);
assert!(
*payment_expire > now && *payment_expire <= now + 7201,
"payment 过期时间应在 now+7200 附近,实际: {}, now={}",
payment_expire,
now
);
}
#[tokio::test]
async fn t022_open_safe_overwrites_existing_marker() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-1003", &LoginParams::default())
.await
.unwrap();
with_current_token(token.clone(), async {
logic.open_safe("default", 100).await.unwrap();
})
.await;
let ts1 = logic
.session
.get_token_session(&token)
.await
.unwrap()
.unwrap();
let expire1 = *ts1
.safe_services
.get("default")
.expect("第一次 open_safe 后 default 应存在");
with_current_token(token.clone(), async {
logic.open_safe("default", 200).await.unwrap();
})
.await;
let ts2 = logic
.session
.get_token_session(&token)
.await
.unwrap()
.unwrap();
let expire2 = *ts2
.safe_services
.get("default")
.expect("第二次 open_safe 后 default 应存在");
let now = chrono::Utc::now().timestamp();
assert!(
expire2 > expire1,
"第二次 open_safe 应覆盖第一次,过期时间应更新,实际: expire1={}, expire2={}",
expire1,
expire2
);
assert!(
expire2 >= now + 199 && expire2 <= now + 201,
"过期时间应在 now+200 附近,实际: expire2={}, now={}",
expire2,
now
);
assert_eq!(
ts2.safe_services.len(),
1,
"覆盖后 safe_services 应仍为 1 个 entry,实际: {:?}",
ts2.safe_services
);
}
#[tokio::test]
async fn t022_open_safe_duration_zero_immediate_expiry() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-1004", &LoginParams::default())
.await
.unwrap();
with_current_token(token.clone(), async {
logic.open_safe("default", 0).await.unwrap();
})
.await;
let ts = logic
.session
.get_token_session(&token)
.await
.unwrap()
.unwrap();
let expire = ts
.safe_services
.get("default")
.expect("default 应在 safe_services 中");
let now = chrono::Utc::now().timestamp();
assert!(
*expire <= now,
"duration=0 时过期时间应 <= now(已过期),实际: expire={}, now={}",
expire,
now
);
assert!(
*expire >= now - 5,
"过期时间应在 now 附近(允许 5 秒偏差),实际: expire={}, now={}",
expire,
now
);
}
#[tokio::test]
async fn t022_open_safe_no_session_returns_err() {
let (logic, _dao) = make_logic();
let result = logic.open_safe("default", 3600).await;
match result {
Err(GarrisonError::Session(msg)) => {
assert!(
msg.contains("stp-context-not-set"),
"Session 错误消息应说明未设置 current_token,实际: {}",
msg
);
},
other => panic!("期望 Err(GarrisonError::Session),实际: {:?}", other),
}
}
#[tokio::test]
async fn t022_open_safe_token_not_exist_returns_err() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-1006", &LoginParams::default())
.await
.unwrap();
logic.session.logout(&token).await.unwrap();
let result = with_current_token(token.clone(), async {
logic.open_safe("default", 3600).await
})
.await;
match result {
Err(GarrisonError::InvalidToken(msg)) => {
let expected_prefix = if token.len() >= 8 {
&token[..8]
} else {
&token
};
assert!(
msg.contains(expected_prefix),
"InvalidToken 错误消息应包含 token 前缀,实际: {}",
msg
);
assert!(
!msg.contains(&token) || token.len() <= 8,
"InvalidToken 错误消息不应包含完整 token(脱敏),实际: {}",
msg
);
},
other => panic!("期望 Err(GarrisonError::InvalidToken),实际: {:?}", other),
}
}
#[tokio::test]
async fn t023_is_safe_returns_true_within_validity() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-2001", &LoginParams::default())
.await
.unwrap();
let result = with_current_token(token.clone(), async {
logic.open_safe("default", 3600).await.unwrap();
logic.is_safe("default").await
})
.await;
assert!(
result.unwrap(),
"open_safe 后 3600 秒内 is_safe 应返回 true"
);
}
#[tokio::test]
async fn t023_is_safe_returns_false_after_expiry() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-2002", &LoginParams::default())
.await
.unwrap();
let result = with_current_token(token.clone(), async {
logic.open_safe("default", 0).await.unwrap();
logic.is_safe("default").await
})
.await;
assert!(
!result.unwrap(),
"duration=0 立即过期,is_safe 应返回 false"
);
}
#[tokio::test]
async fn t023_is_safe_returns_false_without_marker() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-2003", &LoginParams::default())
.await
.unwrap();
let result = with_current_token(token.clone(), async {
logic.open_safe("default", 3600).await.unwrap();
logic.is_safe("payment").await
})
.await;
assert!(
!result.unwrap(),
"payment 未 open_safe,is_safe 应返回 false"
);
}
#[tokio::test]
async fn t023_is_safe_multi_service_independent() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-2004", &LoginParams::default())
.await
.unwrap();
with_current_token(token.clone(), async {
logic.open_safe("default", 3600).await.unwrap();
logic.open_safe("payment", 7200).await.unwrap();
})
.await;
let (safe_default, safe_payment) = with_current_token(token.clone(), async {
(
logic.is_safe("default").await.unwrap(),
logic.is_safe("payment").await.unwrap(),
)
})
.await;
assert!(safe_default, "default 应处于有效期内");
assert!(safe_payment, "payment 应处于有效期内");
let now = chrono::Utc::now().timestamp();
let mut ts = logic
.session
.get_token_session(&token)
.await
.unwrap()
.unwrap();
ts.safe_services.insert("payment".to_string(), now - 100);
logic.session.save_token_session(&token, &ts).await.unwrap();
let (safe_default_after, safe_payment_after) = with_current_token(token.clone(), async {
(
logic.is_safe("default").await.unwrap(),
logic.is_safe("payment").await.unwrap(),
)
})
.await;
assert!(
safe_default_after,
"payment 过期不应影响 default,default 应仍为 true"
);
assert!(!safe_payment_after, "payment 过期后 is_safe 应返回 false");
}
#[tokio::test]
async fn t023_is_safe_returns_false_after_marker_removed() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-2005", &LoginParams::default())
.await
.unwrap();
with_current_token(token.clone(), async {
logic.open_safe("default", 3600).await.unwrap();
})
.await;
let mut ts = logic
.session
.get_token_session(&token)
.await
.unwrap()
.unwrap();
ts.safe_services.remove("default");
logic.session.save_token_session(&token, &ts).await.unwrap();
let result =
with_current_token(token.clone(), async { logic.is_safe("default").await }).await;
assert!(
!result.unwrap(),
"删除 safe_services 标记后 is_safe 应返回 false"
);
}
#[tokio::test]
async fn t023_is_safe_returns_false_when_not_logged_in() {
let (logic, _dao) = make_logic();
let result = logic.is_safe("default").await;
assert!(
result.is_ok(),
"未登录时 is_safe 应返回 Ok(false) 而非 Err,实际: {:?}",
result
);
assert!(!result.unwrap(), "未登录时 is_safe 应返回 Ok(false)");
}
#[tokio::test]
async fn t023_is_safe_empty_service_returns_err() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-2007", &LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async { logic.is_safe("").await }).await;
match result {
Err(GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("service"),
"InvalidParam 错误消息应说明 service 参数问题,实际: {}",
msg
);
},
other => panic!("期望 Err(InvalidParam),实际: {:?}", other),
}
}
#[tokio::test]
async fn t024_close_safe_removes_existing_marker() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-3001", &LoginParams::default())
.await
.unwrap();
with_current_token(token.clone(), async {
logic.open_safe("default", 3600).await.unwrap();
logic.close_safe("default").await.unwrap();
})
.await;
let ts = logic
.session
.get_token_session(&token)
.await
.unwrap()
.unwrap();
assert_eq!(
ts.safe_services.len(),
0,
"close_safe 后 default 条目应被移除,safe_services 应为空,实际: {:?}",
ts.safe_services
);
assert!(
!ts.safe_services.contains_key("default"),
"default 不应仍在 safe_services 中"
);
}
#[tokio::test]
async fn t024_close_safe_nonexistent_marker_is_noop() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-3002", &LoginParams::default())
.await
.unwrap();
let result =
with_current_token(token.clone(), async { logic.close_safe("default").await }).await;
assert!(
result.is_ok(),
"close_safe 不存在的标记应幂等返回 Ok(()),实际: {:?}",
result
);
let ts = logic
.session
.get_token_session(&token)
.await
.unwrap()
.unwrap();
assert_eq!(
ts.safe_services.len(),
0,
"未 open_safe 直接 close_safe 后 safe_services 应仍为空,实际: {:?}",
ts.safe_services
);
}
#[tokio::test]
async fn t024_close_safe_then_is_safe_returns_false() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-3003", &LoginParams::default())
.await
.unwrap();
let (before, after) = with_current_token(token.clone(), async {
logic.open_safe("default", 3600).await.unwrap();
let before = logic.is_safe("default").await.unwrap();
logic.close_safe("default").await.unwrap();
let after = logic.is_safe("default").await.unwrap();
(before, after)
})
.await;
assert!(before, "open_safe 后 is_safe 应返回 true");
assert!(!after, "close_safe 后 is_safe 应返回 false");
}
#[tokio::test]
async fn t024_close_safe_only_removes_specified_service() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-3004", &LoginParams::default())
.await
.unwrap();
with_current_token(token.clone(), async {
logic.open_safe("default", 3600).await.unwrap();
logic.open_safe("payment", 7200).await.unwrap();
logic.close_safe("default").await.unwrap();
})
.await;
let ts = logic
.session
.get_token_session(&token)
.await
.unwrap()
.unwrap();
assert_eq!(
ts.safe_services.len(),
1,
"close_safe(default) 后应只剩 1 个 service 标记,实际: {:?}",
ts.safe_services
);
assert!(
!ts.safe_services.contains_key("default"),
"default 应已被 close_safe 移除"
);
assert!(
ts.safe_services.contains_key("payment"),
"payment 应仍存在,未被 close_safe(default) 影响"
);
let (safe_default, safe_payment) = with_current_token(token.clone(), async {
(
logic.is_safe("default").await.unwrap(),
logic.is_safe("payment").await.unwrap(),
)
})
.await;
assert!(
!safe_default,
"close_safe(default) 后 is_safe(default) 应返回 false"
);
assert!(
safe_payment,
"close_safe(default) 不应影响 payment,is_safe(payment) 应仍返回 true"
);
}
#[tokio::test]
async fn t024_close_safe_empty_service_returns_err() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-3005", &LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async { logic.close_safe("").await }).await;
match result {
Err(GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("service"),
"InvalidParam 错误消息应说明 service 参数问题,实际: {}",
msg
);
},
other => panic!("期望 Err(InvalidParam),实际: {:?}", other),
}
}
#[cfg(feature = "security-extra")]
#[tokio::test]
async fn t026_safe_auth_feature_compiles_when_enabled() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-t026-001", &LoginParams::default())
.await
.unwrap();
with_current_token(token, async {
logic.open_safe("default", 3600).await.unwrap();
assert!(
logic.is_safe("default").await.unwrap(),
"open_safe 后 is_safe 应返回 true(inherent method 可访问)"
);
logic.close_safe("default").await.unwrap();
assert!(
!logic.is_safe("default").await.unwrap(),
"close_safe 后 is_safe 应返回 false(inherent method 可访问)"
);
})
.await;
}
#[cfg(all(feature = "full", feature = "security-extra"))]
#[tokio::test]
async fn t026_full_feature_includes_safe_auth() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-t026-003", &LoginParams::default())
.await
.unwrap();
with_current_token(token, async {
logic.open_safe("default", 3600).await.unwrap();
assert!(
logic.is_safe("default").await.unwrap(),
"full feature 启用时 safe-auth 也启用,is_safe inherent method 应可访问"
);
logic.close_safe("default").await.unwrap();
})
.await;
}
struct SlowDao {
inner: Arc<MockDao>,
delay: std::time::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("token: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!();
}
fn make_slow_session(delay: std::time::Duration) -> (Arc<MockDao>, Arc<GarrisonSession>) {
let inner = Arc::new(MockDao::new());
let dao: Arc<dyn GarrisonDao> = Arc::new(SlowDao {
inner: inner.clone(),
delay,
});
let session = Arc::new(GarrisonSession::new(dao, 3600, 86400, 0));
(inner, session)
}
async fn simulate_open_safe(
session: &GarrisonSession,
token: &str,
service: &str,
duration_secs: u64,
) -> GarrisonResult<()> {
let service = service.to_string();
session
.with_token_session_lock(token, async {
let mut ts = session.get_token_session(token).await?.ok_or_else(|| {
GarrisonError::InvalidToken(format!("stp-token-not-found::{}", token))
})?;
let now = chrono::Utc::now().timestamp();
let expire_at = now + duration_secs as i64;
ts.safe_services.insert(service.clone(), expire_at);
session.save_token_session(token, &ts).await
})
.await
}
async fn simulate_close_safe(
session: &GarrisonSession,
token: &str,
service: &str,
) -> GarrisonResult<()> {
let service = service.to_string();
session
.with_token_session_lock(token, async {
let mut ts = session.get_token_session(token).await?.ok_or_else(|| {
GarrisonError::InvalidToken(format!("stp-token-not-found::{}", token))
})?;
ts.safe_services.remove(&service);
session.save_token_session(token, &ts).await
})
.await
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn crit001_concurrent_open_safe_different_services_no_lost_update() {
let (_dao, session) = make_slow_session(std::time::Duration::from_millis(50));
session.create("user-crit001-001", "T1").await.unwrap();
let (r1, r2) = tokio::join!(
simulate_open_safe(&session, "T1", "default", 3600),
simulate_open_safe(&session, "T1", "payment", 7200),
);
r1.expect("open_safe default 应成功");
r2.expect("open_safe payment 应成功");
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert_eq!(
ts.safe_services.len(),
2,
"并发 open_safe 后 safe_services 应包含 2 个 service(修复前 lost update 导致只剩 1 个),实际: {:?}",
ts.safe_services
);
assert!(
ts.safe_services.contains_key("default"),
"default 应在 safe_services 中,实际: {:?}",
ts.safe_services
);
assert!(
ts.safe_services.contains_key("payment"),
"payment 应在 safe_services 中,实际: {:?}",
ts.safe_services
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn crit001_concurrent_close_safe_different_services_no_lost_update() {
let (_dao, session) = make_slow_session(std::time::Duration::from_millis(50));
session.create("user-crit001-002", "T1").await.unwrap();
simulate_open_safe(&session, "T1", "default", 3600)
.await
.unwrap();
simulate_open_safe(&session, "T1", "payment", 7200)
.await
.unwrap();
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert_eq!(ts.safe_services.len(), 2, "前置条件:应有 2 个 service");
let (r1, r2) = tokio::join!(
simulate_close_safe(&session, "T1", "default"),
simulate_close_safe(&session, "T1", "payment"),
);
r1.expect("close_safe default 应成功");
r2.expect("close_safe payment 应成功");
let ts = session.get_token_session("T1").await.unwrap().unwrap();
assert_eq!(
ts.safe_services.len(),
0,
"并发 close_safe 后 safe_services 应为空(修复前 lost update 导致残留 1 个),实际: {:?}",
ts.safe_services
);
}
#[tokio::test]
async fn t023_is_safe_lazy_removes_expired_entry() {
let (logic, _dao) = make_logic();
let token = logic
.login("user-lazy-001", &LoginParams::default())
.await
.unwrap();
let now = chrono::Utc::now().timestamp();
let mut ts = logic
.session
.get_token_session(&token)
.await
.unwrap()
.unwrap();
ts.safe_services
.insert("expired-service".to_string(), now - 3600);
ts.safe_services
.insert("valid-service".to_string(), now + 3600);
logic.session.save_token_session(&token, &ts).await.unwrap();
let result = with_current_token(token.clone(), async {
logic.is_safe("expired-service").await.unwrap()
})
.await;
assert!(!result, "过期条目 is_safe 应返回 false");
let ts_after = logic
.session
.get_token_session(&token)
.await
.unwrap()
.unwrap();
assert!(
!ts_after.safe_services.contains_key("expired-service"),
"过期条目应被惰性删除,实际: {:?}",
ts_after.safe_services
);
assert!(
ts_after.safe_services.contains_key("valid-service"),
"未过期条目不应被删除"
);
}
}