use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use async_trait::async_trait;
use std::collections::HashMap;
use std::time::{Duration, Instant};
use tokio::sync::Mutex;
struct MockEntry {
value: String,
expires_at: Option<Instant>,
}
impl MockEntry {
fn is_expired(&self, now: Instant) -> bool {
matches!(self.expires_at, Some(t) if t <= now)
}
}
pub struct MockDao {
data: Mutex<HashMap<String, MockEntry>>,
}
impl MockDao {
pub fn new() -> Self {
Self {
data: Mutex::new(HashMap::new()),
}
}
}
#[async_trait]
impl GarrisonDao for MockDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
let mut data = self.data.lock().await;
match data.get(key) {
Some(entry) if entry.is_expired(Instant::now()) => {
data.remove(key);
Ok(None)
},
Some(entry) => Ok(Some(entry.value.clone())),
None => Ok(None),
}
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
let expires_at = if ttl_seconds == 0 {
None
} else {
Some(Instant::now() + Duration::from_secs(ttl_seconds))
};
let mut data = self.data.lock().await;
data.insert(
key.to_string(),
MockEntry {
value: value.to_string(),
expires_at,
},
);
Ok(())
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
let mut data = self.data.lock().await;
match data.get_mut(key) {
Some(entry) => {
entry.value = value.to_string();
Ok(())
},
None => Err(GarrisonError::Dao("sso-mock-key-not-found".to_string())),
}
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
let mut data = self.data.lock().await;
match data.get_mut(key) {
Some(entry) => {
entry.expires_at = if seconds == 0 {
None
} else {
Some(Instant::now() + Duration::from_secs(seconds))
};
Ok(())
},
None => Err(GarrisonError::Dao(format!("sso-mock-key-missing::{}", key))),
}
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
let mut data = self.data.lock().await;
data.remove(key);
Ok(())
}
async fn get_and_delete(&self, key: &str) -> GarrisonResult<Option<String>> {
let mut data = self.data.lock().await;
match data.get(key) {
Some(entry) if entry.is_expired(Instant::now()) => {
data.remove(key);
Ok(None)
},
Some(_) => {
let entry = data.remove(key).expect("entry 已确认存在");
Ok(Some(entry.value))
},
None => Ok(None),
}
}
crate::atomic_test_fallback_no_get_and_delete!();
}
#[cfg(test)]
mod mock_dao_coverage_tests {
use super::*;
#[tokio::test]
async fn mock_dao_atomic_and_default_methods_coverage() {
let dao = MockDao::new();
dao.set("k1", "v1", 60).await.unwrap();
let _ = dao.set_if_absent("a1", "v1", 60).await;
let _ = dao.get_and_delete("a1").await;
let _ = dao.incr("ctr", 60).await;
let _ = dao.decr("ctr").await;
let _ = dao.rename("k1", "k2").await;
let _ = dao.compare_and_swap("k2", Some("v1"), "v2", 60).await;
let _ = dao.set_permanent("p1", "val").await;
let _ = dao.get_timeout("k1").await;
let _ = dao.get_with_ttl("k1").await;
let _ = dao.keys("*").await;
let _ = dao.find_social_binding(0, "w", "o").await;
let _ = dao.insert_social_binding(0, "u", "w", "o", None, 0).await;
let _ = dao.compare_and_update_if_greater("k1", 10, 60).await;
let _ = dao.eval_lua("r", vec![], vec![]).await;
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
{
let _ = dao.insert_credit_consumption(0, "r", 1, 1, 1, 0).await;
let _ = dao.query_credit_consumption(0, 0, 0).await;
let _ = dao.query_role_hierarchy_edges(0).await;
let _ = dao.insert_role_hierarchy_edge(0, "c", "p").await;
let _ = dao.delete_role_hierarchy_edge(0, "c", "p").await;
}
}
#[tokio::test]
async fn mock_dao_ttl_expires_key() {
let dao = MockDao::new();
dao.set("ttl-key", "v", 1).await.unwrap();
assert_eq!(dao.get("ttl-key").await.unwrap().as_deref(), Some("v"));
tokio::time::sleep(Duration::from_millis(1100)).await;
assert_eq!(
dao.get("ttl-key").await.unwrap(),
None,
"超过 TTL 后 get 应返回 None"
);
}
#[tokio::test]
async fn mock_dao_ttl_zero_means_permanent() {
let dao = MockDao::new();
dao.set("perm-key", "v", 0).await.unwrap();
tokio::time::sleep(Duration::from_millis(20)).await;
assert_eq!(
dao.get("perm-key").await.unwrap().as_deref(),
Some("v"),
"ttl=0 应永不过期"
);
}
#[tokio::test]
async fn mock_dao_expire_invalidates_key() {
let dao = MockDao::new();
dao.set("exp-key", "v", 0).await.unwrap();
dao.expire("exp-key", 1).await.unwrap();
tokio::time::sleep(Duration::from_millis(1100)).await;
assert_eq!(
dao.get("exp-key").await.unwrap(),
None,
"expire 后超过时长 get 应返回 None"
);
let missing = dao.expire("no-such-key", 10).await;
assert!(
matches!(missing, Err(GarrisonError::Dao(_))),
"对不存在键 expire 应返回 Err,实际: {:?}",
missing
);
}
}