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;
pub struct MockDao {
store: Mutex<HashMap<String, (String, Option<Instant>)>>,
}
impl MockDao {
pub fn new() -> Self {
Self {
store: Mutex::new(HashMap::new()),
}
}
}
#[async_trait]
impl GarrisonDao for MockDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
let mut store = self.store.lock().await;
match store.get(key) {
Some((value, expire_at)) => {
if let Some(deadline) = expire_at {
if Instant::now() >= *deadline {
store.remove(key);
return Ok(None);
}
}
Ok(Some(value.clone()))
},
None => Ok(None),
}
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
let expire_at = if ttl_seconds == 0 {
None
} else {
Some(Instant::now() + Duration::from_secs(ttl_seconds))
};
self.store
.lock()
.await
.insert(key.to_string(), (value.to_string(), expire_at));
Ok(())
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
let mut store = self.store.lock().await;
match store.get_mut(key) {
Some((existing, _)) => {
*existing = value.to_string();
Ok(())
},
None => Err(GarrisonError::Dao(format!("dao-key-not-found::{}", key))),
}
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
let mut store = self.store.lock().await;
match store.get_mut(key) {
Some((_, expire_at)) => {
*expire_at = if seconds == 0 {
None
} else {
Some(Instant::now() + Duration::from_secs(seconds))
};
Ok(())
},
None => Err(GarrisonError::Dao(format!("dao-key-not-found::{}", key))),
}
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
self.store.lock().await.remove(key);
Ok(())
}
async fn get_timeout(&self, key: &str) -> GarrisonResult<Option<Duration>> {
let store = self.store.lock().await;
match store.get(key) {
Some((_, Some(deadline))) => {
let now = Instant::now();
if *deadline <= now {
Ok(None)
} else {
Ok(Some(*deadline - now))
}
},
_ => Ok(None),
}
}
async fn get_with_ttl(&self, key: &str) -> GarrisonResult<Option<(String, Option<Duration>)>> {
let mut store = self.store.lock().await;
match store.get(key) {
Some((value, expire_at)) => {
let now = Instant::now();
match expire_at {
Some(deadline) if *deadline <= now => {
store.remove(key);
Ok(None)
},
Some(deadline) => Ok(Some((value.clone(), Some(*deadline - now)))),
None => Ok(Some((value.clone(), None))),
}
},
None => Ok(None),
}
}
crate::atomic_test_fallback!();
}
#[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();
assert!(
dao.set_if_absent("a1", "v1", 60).await.unwrap(),
"key 不存在时 set_if_absent 应返回 true"
);
assert!(
!dao.set_if_absent("a1", "v2", 60).await.unwrap(),
"key 已存在时 set_if_absent 应返回 false"
);
assert_eq!(
dao.get_and_delete("a1").await.unwrap().as_deref(),
Some("v1"),
"get_and_delete 应返回原值"
);
assert_eq!(
dao.get("a1").await.unwrap(),
None,
"get_and_delete 后键应被删除"
);
assert_eq!(dao.incr("ctr", 60).await.unwrap(), 1, "首次 incr 应为 1");
assert_eq!(dao.incr("ctr", 60).await.unwrap(), 2, "二次 incr 应为 2");
assert_eq!(dao.decr("ctr").await.unwrap(), 1, "decr 应递减到 1");
dao.rename("k1", "k2").await.unwrap();
assert_eq!(dao.get("k1").await.unwrap(), None, "rename 后旧键应删除");
assert_eq!(
dao.get("k2").await.unwrap().as_deref(),
Some("v1"),
"rename 后新键应携带原值"
);
assert!(
dao.compare_and_swap("k2", Some("v1"), "v2", 60)
.await
.unwrap(),
"expected 匹配时 compare_and_swap 应成功"
);
assert!(
!dao.compare_and_swap("k2", Some("v1"), "v3", 60)
.await
.unwrap(),
"expected 不匹配时 compare_and_swap 应返回 false"
);
dao.set_permanent("p1", "val").await.unwrap();
assert_eq!(dao.get("p1").await.unwrap().as_deref(), Some("val"));
assert_eq!(
dao.get_timeout("p1").await.unwrap(),
None,
"永久键 get_timeout 应为 None"
);
let (v, ttl) = dao
.get_with_ttl("k2")
.await
.unwrap()
.expect("已设 TTL 的键 get_with_ttl 应返回 Some");
assert_eq!(v, "v2");
assert!(ttl.is_some(), "设置了 TTL 的键应返回 Some(remaining)");
assert!(
matches!(dao.keys("*").await, Err(GarrisonError::NotImplemented(_))),
"keys 默认实现应返回 NotImplemented"
);
assert!(
matches!(
dao.find_social_binding(0, "w", "o").await,
Err(GarrisonError::NotImplemented(_))
),
"find_social_binding 默认实现应返回 NotImplemented"
);
assert!(
matches!(
dao.insert_social_binding(0, "u", "w", "o", None, 0).await,
Err(GarrisonError::NotImplemented(_))
),
"insert_social_binding 默认实现应返回 NotImplemented"
);
assert!(
matches!(
dao.compare_and_update_if_greater("k1", 10, 60).await,
Err(GarrisonError::NotImplemented(_))
),
"compare_and_update_if_greater 默认实现应返回 NotImplemented"
);
assert!(
matches!(
dao.eval_lua("r", vec![], vec![]).await,
Err(GarrisonError::NotImplemented(_))
),
"eval_lua 默认实现应返回 NotImplemented"
);
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
{
assert!(
matches!(
dao.insert_credit_consumption(0, "r", 1, 1, 1, 0).await,
Err(GarrisonError::NotImplemented(_))
),
"insert_credit_consumption 默认实现应返回 NotImplemented"
);
assert!(
matches!(
dao.query_credit_consumption(0, 0, 0).await,
Err(GarrisonError::NotImplemented(_))
),
"query_credit_consumption 默认实现应返回 NotImplemented"
);
assert!(
matches!(
dao.query_role_hierarchy_edges(0).await,
Err(GarrisonError::NotImplemented(_))
),
"query_role_hierarchy_edges 默认实现应返回 NotImplemented"
);
assert!(
matches!(
dao.insert_role_hierarchy_edge(0, "c", "p").await,
Err(GarrisonError::NotImplemented(_))
),
"insert_role_hierarchy_edge 默认实现应返回 NotImplemented"
);
assert!(
matches!(
dao.delete_role_hierarchy_edge(0, "c", "p").await,
Err(GarrisonError::NotImplemented(_))
),
"delete_role_hierarchy_edge 默认实现应返回 NotImplemented"
);
}
}
}