use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use async_trait::async_trait;
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DisableEntry {
pub login_id: String,
pub service: String,
pub until: Option<DateTime<Utc>>,
pub level: u32,
pub created_at: DateTime<Utc>,
}
#[async_trait]
pub trait DisableRepository: Send + Sync {
async fn disable(
&self,
login_id: &str,
service: &str,
until: Option<DateTime<Utc>>,
level: u32,
duration_secs: u64,
) -> GarrisonResult<()>;
async fn untie_disable(&self, login_id: &str, service: &str) -> GarrisonResult<()>;
async fn is_disable(&self, login_id: &str, service: &str) -> GarrisonResult<bool>;
async fn get_disable_time(
&self,
login_id: &str,
service: &str,
) -> GarrisonResult<Option<DateTime<Utc>>>;
async fn get_disable_level(&self, login_id: &str, service: &str)
-> GarrisonResult<Option<u32>>;
}
pub struct DefaultDisableRepository {
dao: Arc<dyn GarrisonDao>,
}
impl DefaultDisableRepository {
pub fn new(dao: Arc<dyn GarrisonDao>) -> Self {
Self { dao }
}
fn disable_key(service: &str, login_id: &str) -> GarrisonResult<String> {
if service.contains(':') {
return Err(GarrisonError::Config(format!(
"account-disable-service-colon::{}",
service
)));
}
if login_id.contains(':') {
return Err(GarrisonError::Config(format!(
"account-disable-login-id-colon::{}",
login_id
)));
}
Ok(format!("disable:{}:{}", service, login_id))
}
async fn get_active_entry(
&self,
login_id: &str,
service: &str,
) -> GarrisonResult<Option<DisableEntry>> {
let key = Self::disable_key(service, login_id)?;
match self.dao.get(&key).await? {
Some(json) => {
let entry: DisableEntry = serde_json::from_str(&json).map_err(|e| {
GarrisonError::Dao(format!("account-disable-deserialize::{}", e))
})?;
match entry.until {
Some(until) if Utc::now() >= until => Ok(None),
_ => Ok(Some(entry)),
}
},
None => Ok(None),
}
}
}
#[async_trait]
impl DisableRepository for DefaultDisableRepository {
async fn disable(
&self,
login_id: &str,
service: &str,
until: Option<DateTime<Utc>>,
level: u32,
duration_secs: u64,
) -> GarrisonResult<()> {
let entry = DisableEntry {
login_id: login_id.to_string(),
service: service.to_string(),
until,
level,
created_at: Utc::now(),
};
let json = serde_json::to_string(&entry)
.map_err(|e| GarrisonError::Internal(format!("account-disable-serialize::{}", e)))?;
let key = Self::disable_key(service, login_id)?;
let effective_ttl = match until {
Some(until) => {
let remaining = (until - Utc::now()).num_seconds();
let remaining = u64::try_from(remaining).unwrap_or(0);
duration_secs.max(remaining)
},
None => duration_secs,
};
if effective_ttl == 0 {
self.dao.set_permanent(&key, &json).await
} else {
self.dao.set(&key, &json, effective_ttl).await
}
}
async fn untie_disable(&self, login_id: &str, service: &str) -> GarrisonResult<()> {
let key = Self::disable_key(service, login_id)?;
self.dao.delete(&key).await
}
async fn is_disable(&self, login_id: &str, service: &str) -> GarrisonResult<bool> {
Ok(self.get_active_entry(login_id, service).await?.is_some())
}
async fn get_disable_time(
&self,
login_id: &str,
service: &str,
) -> GarrisonResult<Option<DateTime<Utc>>> {
let entry = self.get_active_entry(login_id, service).await?;
Ok(entry.and_then(|e| e.until))
}
async fn get_disable_level(
&self,
login_id: &str,
service: &str,
) -> GarrisonResult<Option<u32>> {
let entry = self.get_active_entry(login_id, service).await?;
Ok(entry.map(|e| e.level))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::InMemoryDao;
#[tokio::test]
async fn t016_disable_writes_entry_to_dao() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
let until = Utc::now() + chrono::Duration::seconds(3600);
repo.disable("user-1001", "default", Some(until), 0, 3600)
.await
.unwrap();
let key = "disable:default:user-1001";
let stored = dao.get(key).await.unwrap();
assert!(stored.is_some(), "disable 后 DAO 中应存在对应 key");
let entry: DisableEntry = serde_json::from_str(&stored.unwrap()).unwrap();
assert_eq!(entry.login_id, "user-1001");
assert_eq!(entry.service, "default");
assert_eq!(entry.until, Some(until));
assert_eq!(entry.level, 0);
}
#[tokio::test]
async fn t016_untie_disable_removes_entry_from_dao() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
repo.disable("user-1002", "default", None, 0, 0)
.await
.unwrap();
let key = "disable:default:user-1002";
assert!(dao.get(key).await.unwrap().is_some());
repo.untie_disable("user-1002", "default").await.unwrap();
assert!(
dao.get(key).await.unwrap().is_none(),
"untie_disable 后 DAO 中 key 应不存在"
);
}
#[tokio::test]
async fn t016_disable_key_format_is_service_then_login_id() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
repo.disable("user-1003", "payment", None, 0, 0)
.await
.unwrap();
let expected_key = "disable:payment:user-1003";
assert!(
dao.get(expected_key).await.unwrap().is_some(),
"key 应为 disable:payment:user-1003(service 在前)"
);
let wrong_key = "disable:user-1003:payment";
assert!(
dao.get(wrong_key).await.unwrap().is_none(),
"反序 key 不应存在"
);
}
#[tokio::test]
async fn t016_disable_with_zero_duration_is_permanent() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
repo.disable("user-1004", "default", None, 0, 0)
.await
.unwrap();
let key = "disable:default:user-1004";
let timeout = dao.get_timeout(key).await.unwrap();
assert!(
timeout.is_none(),
"duration_secs=0 应为永久驻留,get_timeout 应返回 None"
);
}
#[tokio::test]
async fn t016_disable_passes_level_to_entry() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
repo.disable("user-1005", "default", None, 2, 3600)
.await
.unwrap();
let key = "disable:default:user-1005";
let stored = dao.get(key).await.unwrap().unwrap();
let entry: DisableEntry = serde_json::from_str(&stored).unwrap();
assert_eq!(entry.level, 2, "disable 传入 level=2 应写入 entry.level=2");
}
#[tokio::test]
async fn t016_multiple_disable_overwrites_previous() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
repo.disable("user-1006", "default", None, 1, 0)
.await
.unwrap();
let key = "disable:default:user-1006";
let entry1: DisableEntry =
serde_json::from_str(&dao.get(key).await.unwrap().unwrap()).unwrap();
assert_eq!(entry1.level, 1);
repo.disable("user-1006", "default", None, 3, 0)
.await
.unwrap();
let entry2: DisableEntry =
serde_json::from_str(&dao.get(key).await.unwrap().unwrap()).unwrap();
assert_eq!(entry2.level, 3, "第二次 disable 应覆盖第一次,level 应为 3");
}
#[tokio::test]
async fn t016_disable_then_is_disable_returns_true() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
assert!(
!repo.is_disable("user-1007", "default").await.unwrap(),
"未封禁时 is_disable 应返回 false"
);
repo.disable("user-1007", "default", None, 0, 0)
.await
.unwrap();
assert!(
repo.is_disable("user-1007", "default").await.unwrap(),
"disable 后 is_disable 应返回 true"
);
}
#[tokio::test]
async fn t016_untie_disable_missing_key_returns_ok() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
let result = repo.untie_disable("never_disabled", "default").await;
assert!(
result.is_ok(),
"untie_disable 对不存在的 key 应返回 Ok,实际: {:?}",
result
);
}
#[tokio::test]
async fn t017_is_disable_returns_false_for_unbanned_service() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
repo.disable("user-2001", "default", None, 0, 0)
.await
.unwrap();
assert!(
!repo.is_disable("user-2001", "payment").await.unwrap(),
"同一 login_id 在未封禁的 service 上 is_disable 应返回 false"
);
}
#[tokio::test]
async fn t017_is_disable_returns_true_for_timed_ban() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
let until = Utc::now() + chrono::Duration::seconds(3600);
repo.disable("user-2002", "default", Some(until), 0, 3600)
.await
.unwrap();
assert!(
repo.is_disable("user-2002", "default").await.unwrap(),
"定时封禁后 is_disable 应返回 true"
);
}
#[tokio::test]
async fn t017_get_disable_time_returns_none_for_permanent_ban() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
repo.disable("user-2003", "default", None, 0, 0)
.await
.unwrap();
assert_eq!(
repo.get_disable_time("user-2003", "default").await.unwrap(),
None,
"永久封禁 get_disable_time 应返回 Ok(None)"
);
}
#[tokio::test]
async fn t017_get_disable_time_returns_some_for_timed_ban() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
let until = Utc::now() + chrono::Duration::seconds(7200);
repo.disable("user-2004", "default", Some(until), 0, 7200)
.await
.unwrap();
let result = repo.get_disable_time("user-2004", "default").await.unwrap();
assert_eq!(
result,
Some(until),
"定时封禁 get_disable_time 应返回 Ok(Some(until)),时间值精确匹配"
);
}
#[tokio::test]
async fn t017_get_disable_level_returns_correct_value() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
repo.disable("user-2005", "default", None, 2, 0)
.await
.unwrap();
assert_eq!(
repo.get_disable_level("user-2005", "default")
.await
.unwrap(),
Some(2),
"disable(level=2) 后 get_disable_level 应返回 Ok(Some(2))"
);
}
#[tokio::test]
async fn t017_get_disable_level_returns_none_when_not_banned() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
assert_eq!(
repo.get_disable_level("never_banned", "default")
.await
.unwrap(),
None,
"未封禁时 get_disable_level 应返回 Ok(None)"
);
}
#[tokio::test]
async fn t017_get_disable_time_returns_err_on_deserialize_failure() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
let key = "disable:default:user-2006";
dao.set(key, "{invalid json}", 0).await.unwrap();
let result = repo.get_disable_time("user-2006", "default").await;
assert!(
matches!(result, Err(GarrisonError::Dao(ref msg)) if msg.contains("account-disable-deserialize")),
"损坏 JSON 应返回 Err(GarrisonError::Dao) 含 '反序列化 DisableEntry 失败',实际: {:?}",
result
);
}
#[tokio::test]
async fn t017_is_disable_returns_false_after_untie_disable() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
repo.disable("user-2007", "default", None, 0, 0)
.await
.unwrap();
assert!(
repo.is_disable("user-2007", "default").await.unwrap(),
"disable 后 is_disable 应为 true"
);
repo.untie_disable("user-2007", "default").await.unwrap();
assert!(
!repo.is_disable("user-2007", "default").await.unwrap(),
"untie_disable 后 is_disable 应返回 false"
);
}
#[tokio::test]
async fn t017_get_disable_time_returns_none_when_not_banned() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
assert_eq!(
repo.get_disable_time("never_banned", "default")
.await
.unwrap(),
None,
"未封禁时 get_disable_time 应返回 Ok(None)"
);
}
#[tokio::test]
async fn t018_level_zero_normal_ban() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
repo.disable("user-3001", "default", None, 0, 0)
.await
.unwrap();
assert_eq!(
repo.get_disable_level("user-3001", "default")
.await
.unwrap(),
Some(0),
"level=0 普通封禁,get_disable_level 应返回 Ok(Some(0))"
);
}
#[tokio::test]
async fn t018_level_one_first_escalation() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
repo.disable("user-3002", "default", None, 1, 0)
.await
.unwrap();
assert_eq!(
repo.get_disable_level("user-3002", "default")
.await
.unwrap(),
Some(1),
"level=1 一级封禁,get_disable_level 应返回 Ok(Some(1))"
);
}
#[tokio::test]
async fn t018_level_three_full_ban() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
repo.disable("user-3003", "default", None, 3, 0)
.await
.unwrap();
assert_eq!(
repo.get_disable_level("user-3003", "default")
.await
.unwrap(),
Some(3),
"level=3 三级封禁,get_disable_level 应返回 Ok(Some(3))"
);
}
#[tokio::test]
async fn t018_get_disable_level_returns_correct_high_value() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
repo.disable("user-3004", "default", None, 10, 0)
.await
.unwrap();
assert_eq!(
repo.get_disable_level("user-3004", "default")
.await
.unwrap(),
Some(10),
"level=10 高级封禁,get_disable_level 应返回 Ok(Some(10)) 无截断"
);
let key = "disable:default:user-3004";
let stored = dao.get(key).await.unwrap().unwrap();
let entry: DisableEntry = serde_json::from_str(&stored).unwrap();
assert_eq!(
entry.level, 10,
"DAO 中的 JSON 反序列化后 level 字段应为 10"
);
}
#[tokio::test]
async fn h001_disable_rejects_colon_in_service() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao);
let result = repo.disable("1001", "evil:service", None, 0, 0).await;
assert!(result.is_err(), "service 含冒号应被拒绝(避免 key 注入)");
}
#[tokio::test]
async fn h001_disable_rejects_colon_in_login_id() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao);
let result = repo.disable("evil:login", "default", None, 0, 0).await;
assert!(result.is_err(), "login_id 含冒号应被拒绝(避免 key 注入)");
}
#[tokio::test]
async fn expired_entry_all_queries_treated_as_not_disabled() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
let past = Utc::now() - chrono::Duration::hours(1);
repo.disable("user-expired", "default", Some(past), 3, 0)
.await
.unwrap();
let key = "disable:default:user-expired";
assert!(
dao.get(key).await.unwrap().is_some(),
"key 应仍存在(TTL=0)"
);
assert!(
!repo.is_disable("user-expired", "default").await.unwrap(),
"过期条目 is_disable 应为 false"
);
assert_eq!(
repo.get_disable_time("user-expired", "default")
.await
.unwrap(),
None,
"过期条目 get_disable_time 应返回 None(与 is_disable 一致)"
);
assert_eq!(
repo.get_disable_level("user-expired", "default")
.await
.unwrap(),
None,
"过期条目 get_disable_level 应返回 None(与 is_disable 一致)"
);
}
#[tokio::test]
async fn disable_ttl_uses_max_of_duration_and_until() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
let until = Utc::now() + chrono::Duration::hours(1);
repo.disable("user-ttl", "default", Some(until), 0, 60)
.await
.unwrap();
let key = "disable:default:user-ttl";
let ttl = dao
.get_timeout(key)
.await
.unwrap()
.expect("key 应有 TTL")
.as_secs();
assert!(
ttl > 3540,
"实际 TTL 应取 max(60, until 剩余≈3600) ≈ 3600 秒,实际: {} 秒",
ttl
);
}
#[tokio::test]
async fn disable_ttl_longer_than_until_uses_duration() {
let dao = Arc::new(InMemoryDao::new());
let repo = DefaultDisableRepository::new(dao.clone());
let until = Utc::now() + chrono::Duration::seconds(60);
repo.disable("user-ttl2", "default", Some(until), 0, 3600)
.await
.unwrap();
let key = "disable:default:user-ttl2";
let ttl = dao
.get_timeout(key)
.await
.unwrap()
.expect("key 应有 TTL")
.as_secs();
assert!(
(3595..=3600).contains(&ttl),
"实际 TTL 应为 max(3600, ≈60) = 3600 秒,实际: {} 秒",
ttl
);
assert!(repo.is_disable("user-ttl2", "default").await.unwrap());
}
}