use std::future::Future;
use std::sync::Arc;
use crate::constants::DaoKeyPrefix;
use crate::dao::GarrisonDao;
use crate::error::GarrisonResult;
use crate::session::account_key;
pub struct DataErasureService {
dao: Arc<dyn GarrisonDao>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ErasureReport {
pub login_id: String,
pub erased_keys: Vec<String>,
pub session_erasure_delegated: bool,
pub residual_guidance: Vec<String>,
}
impl DataErasureService {
pub fn new(dao: Arc<dyn GarrisonDao>) -> Self {
Self { dao }
}
pub async fn erase_subject<F, Fut>(
&self,
login_id: &str,
session_erasure: F,
) -> GarrisonResult<ErasureReport>
where
F: FnOnce(String) -> Fut,
Fut: Future<Output = GarrisonResult<()>>,
{
let mut erased_keys = Vec::new();
let delegated = session_erasure(login_id.to_string()).await.is_ok();
let account_key = account_key(login_id);
self.dao.delete(&account_key).await?;
erased_keys.push(account_key);
let lockout_key = DaoKeyPrefix::Lockout.build_key(login_id);
self.dao.delete(&lockout_key).await?;
erased_keys.push(lockout_key);
Ok(ErasureReport {
login_id: login_id.to_string(),
erased_keys,
session_erasure_delegated: delegated,
residual_guidance: residual_guidance(),
})
}
pub async fn erase_ip_artifacts(&self, ip: &str) -> GarrisonResult<ErasureReport> {
let count_key = format!("{}{}:count", DaoKeyPrefix::BruteForce, ip);
self.dao.delete(&count_key).await?;
Ok(ErasureReport {
login_id: ip.to_string(),
erased_keys: vec![count_key],
session_erasure_delegated: false,
residual_guidance: vec![crate::i18n::translate_detail(
"compliance-erasure-residual-ip-artifacts",
&[],
)],
})
}
}
fn residual_guidance() -> Vec<String> {
const KEYS: [&str; 5] = [
"compliance-erasure-residual-api-key",
"compliance-erasure-residual-audit-log",
"compliance-erasure-residual-business-data",
"compliance-erasure-residual-verification-code",
"compliance-erasure-residual-issued-jwt",
];
KEYS.iter()
.map(|key| crate::i18n::translate_detail(*key, &[]))
.collect()
}
#[cfg(all(test, feature = "data-erasure"))]
mod tests {
use super::*;
use crate::dao::InMemoryDao;
fn service() -> (DataErasureService, Arc<InMemoryDao>) {
let dao = Arc::new(InMemoryDao::new());
(DataErasureService::new(dao.clone()), dao)
}
#[tokio::test]
async fn erase_subject_removes_locatable_keys_and_delegates() {
let (service, dao) = service();
dao.set(&account_key("1001"), "account-session", 3600)
.await
.unwrap();
dao.set(&DaoKeyPrefix::Lockout.build_key("1001"), "lockout-state", 0)
.await
.unwrap();
dao.set(&account_key("2002"), "other-subject", 3600)
.await
.unwrap();
let dao_for_delegate = dao.clone();
let delegated = move |id: String| async move {
dao_for_delegate.delete(&account_key(&id)).await.unwrap();
Ok(())
};
let report = service.erase_subject("1001", delegated).await.unwrap();
assert!(report.session_erasure_delegated);
assert!(
report.erased_keys.contains(&account_key("1001")),
"应含 account-session 键: {:?}",
report.erased_keys
);
assert!(
report
.erased_keys
.contains(&DaoKeyPrefix::Lockout.build_key("1001")),
"应含 lockout 键: {:?}",
report.erased_keys
);
assert!(
dao.get(&account_key("1001")).await.unwrap().is_none(),
"account-session 键应已删除"
);
assert!(
dao.get(&DaoKeyPrefix::Lockout.build_key("1001"))
.await
.unwrap()
.is_none(),
"lockout 键应已删除"
);
assert!(
dao.get(&account_key("2002")).await.unwrap().is_some(),
"无关主体键不得被误删"
);
assert!(
!report.residual_guidance.is_empty(),
"报告应含业务方残留处置提示"
);
assert_eq!(report.login_id, "1001");
}
#[tokio::test]
async fn erase_subject_surfaces_delegation_failure_without_aborting() {
let (service, dao) = service();
dao.set(&account_key("1001"), "v", 60).await.unwrap();
let failing =
|_id: String| async { Err(crate::error::GarrisonError::Internal("boom".into())) };
let report = service.erase_subject("1001", failing).await.unwrap();
assert!(
!report.session_erasure_delegated,
"委托失败应在报告中显性暴露"
);
assert!(
dao.get(&account_key("1001")).await.unwrap().is_none(),
"委托失败不得中断可定位键的删除"
);
}
#[tokio::test]
async fn erase_subject_trivial_delegate_reports_by_closure_outcome() {
let (service, _dao) = service();
let report = service
.erase_subject("1001", |_id| async { Ok(()) })
.await
.unwrap();
assert!(report.session_erasure_delegated);
}
#[tokio::test]
async fn erase_ip_artifacts_removes_brute_force_count() {
let (service, dao) = service();
let key = format!("{}{}:count", DaoKeyPrefix::BruteForce, "203.0.113.7");
dao.set(&key, "3", 3600).await.unwrap();
let report = service.erase_ip_artifacts("203.0.113.7").await.unwrap();
assert_eq!(report.erased_keys, vec![key.clone()]);
assert!(dao.get(&key).await.unwrap().is_none());
}
#[tokio::test]
async fn erase_subject_is_idempotent() {
let (service, _dao) = service();
service
.erase_subject("1001", |_id| async { Ok(()) })
.await
.unwrap();
let second = service
.erase_subject("1001", |_id| async { Ok(()) })
.await
.unwrap();
assert!(!second.erased_keys.is_empty(), "幂等删除仍返回键清单");
}
}