use crate::constants::DaoKeyPrefix;
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use crate::strategy::GarrisonPermissionStrategy;
use dashmap::DashMap;
use oxcache::Cache;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::RwLock;
pub struct UserCacheService {
l1: Cache<String, String>,
dao: Arc<dyn GarrisonDao>,
interface: Arc<dyn GarrisonPermissionStrategy>,
l1_ttl_secs: u64,
l2_ttl_secs: u64,
singleflight_locks: DashMap<String, Arc<RwLock<()>>>,
}
impl UserCacheService {
pub fn new(
dao: Arc<dyn GarrisonDao>,
interface: Arc<dyn GarrisonPermissionStrategy>,
l1_ttl_secs: u64,
l2_ttl_secs: u64,
l1_capacity: u64,
) -> GarrisonResult<Self> {
let _ = l1_capacity; let l1 = Cache::new();
Ok(Self {
l1,
dao,
interface,
l1_ttl_secs,
l2_ttl_secs,
singleflight_locks: DashMap::new(),
})
}
fn singleflight_lock(&self, key: &str) -> Arc<RwLock<()>> {
self.singleflight_locks
.entry(key.to_string())
.or_insert_with(|| Arc::new(RwLock::new(())))
.clone()
}
pub fn l1_ttl_secs(&self) -> u64 {
self.l1_ttl_secs
}
pub fn l2_ttl_secs(&self) -> u64 {
self.l2_ttl_secs
}
pub async fn get_permissions(&self, login_id: &str) -> GarrisonResult<Vec<String>> {
let key = DaoKeyPrefix::PermissionCache.build_key(login_id);
if let Some(cached) = self
.l1
.get(&key)
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-get::{}", e)))?
{
let perms: Vec<String> = serde_json::from_str(&cached)
.map_err(|e| GarrisonError::Internal(format!("cache-l1-perm-deser::{}", e)))?;
return Ok(perms);
}
let lock = self.singleflight_lock(&key);
let _guard = lock.write().await;
if let Some(cached) = self
.l1
.get(&key)
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-get::{}", e)))?
{
let perms: Vec<String> = serde_json::from_str(&cached)
.map_err(|e| GarrisonError::Internal(format!("cache-l1-perm-deser::{}", e)))?;
return Ok(perms);
}
if let Some(cached) = self.dao.get(&key).await? {
self.l1
.set_with_ttl(&key, &cached, Some(Duration::from_secs(self.l1_ttl_secs)))
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-set::{}", e)))?;
let perms: Vec<String> = serde_json::from_str(&cached)
.map_err(|e| GarrisonError::Internal(format!("cache-l2-perm-deser::{}", e)))?;
return Ok(perms);
}
let perms = self.interface.get_permission_list(login_id).await?;
let serialized = serde_json::to_string(&perms)
.map_err(|e| GarrisonError::Internal(format!("cache-perm-serialize::{}", e)))?;
self.l1
.set_with_ttl(
&key,
&serialized,
Some(Duration::from_secs(self.l1_ttl_secs)),
)
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-set::{}", e)))?;
self.dao.set(&key, &serialized, self.l2_ttl_secs).await?;
Ok(perms)
}
pub async fn get_roles(&self, login_id: &str) -> GarrisonResult<Vec<String>> {
let key = DaoKeyPrefix::RoleCache.build_key(login_id);
if let Some(cached) = self
.l1
.get(&key)
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-get::{}", e)))?
{
let roles: Vec<String> = serde_json::from_str(&cached)
.map_err(|e| GarrisonError::Internal(format!("cache-l1-role-deser::{}", e)))?;
return Ok(roles);
}
let lock = self.singleflight_lock(&key);
let _guard = lock.write().await;
if let Some(cached) = self
.l1
.get(&key)
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-get::{}", e)))?
{
let roles: Vec<String> = serde_json::from_str(&cached)
.map_err(|e| GarrisonError::Internal(format!("cache-l1-role-deser::{}", e)))?;
return Ok(roles);
}
if let Some(cached) = self.dao.get(&key).await? {
self.l1
.set_with_ttl(&key, &cached, Some(Duration::from_secs(self.l1_ttl_secs)))
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-set::{}", e)))?;
let roles: Vec<String> = serde_json::from_str(&cached)
.map_err(|e| GarrisonError::Internal(format!("cache-l2-role-deser::{}", e)))?;
return Ok(roles);
}
let roles = self.interface.get_role_list(login_id).await?;
let serialized = serde_json::to_string(&roles)
.map_err(|e| GarrisonError::Internal(format!("cache-role-serialize::{}", e)))?;
self.l1
.set_with_ttl(
&key,
&serialized,
Some(Duration::from_secs(self.l1_ttl_secs)),
)
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-set::{}", e)))?;
self.dao.set(&key, &serialized, self.l2_ttl_secs).await?;
Ok(roles)
}
pub async fn get_user(&self, login_id: &str) -> GarrisonResult<Option<String>> {
let key = DaoKeyPrefix::UserCache.build_key(login_id);
if let Some(cached) = self
.l1
.get(&key)
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-get::{}", e)))?
{
return Ok(Some(cached));
}
let lock = self.singleflight_lock(&key);
let _guard = lock.write().await;
if let Some(cached) = self
.l1
.get(&key)
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-get::{}", e)))?
{
return Ok(Some(cached));
}
if let Some(cached) = self.dao.get(&key).await? {
self.l1
.set_with_ttl(&key, &cached, Some(Duration::from_secs(self.l1_ttl_secs)))
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-set::{}", e)))?;
return Ok(Some(cached));
}
let user_info = self.interface.get_user_info(login_id).await?;
if let Some(ref info) = user_info {
self.l1
.set_with_ttl(&key, info, Some(Duration::from_secs(self.l1_ttl_secs)))
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-set::{}", e)))?;
self.dao.set(&key, info, self.l2_ttl_secs).await?;
}
Ok(user_info)
}
pub async fn invalidate(&self, login_id: &str) -> GarrisonResult<()> {
let perm_key = DaoKeyPrefix::PermissionCache.build_key(login_id);
let role_key = DaoKeyPrefix::RoleCache.build_key(login_id);
let user_key = DaoKeyPrefix::UserCache.build_key(login_id);
self.dao.delete(&perm_key).await?;
self.dao.delete(&role_key).await?;
self.dao.delete(&user_key).await?;
self.l1
.delete(&perm_key)
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-delete::{}", e)))?;
self.l1
.delete(&role_key)
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-delete::{}", e)))?;
self.l1
.delete(&user_key)
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-delete::{}", e)))?;
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::GarrisonDao;
use crate::error::GarrisonResult;
use async_trait::async_trait;
use parking_lot::Mutex;
use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
use std::sync::Arc;
struct CountingMockDao {
store: Mutex<HashMap<String, String>>,
get_count: AtomicU32,
set_count: AtomicU32,
delete_count: AtomicU32,
get_keys: Mutex<Vec<String>>,
set_keys: Mutex<Vec<String>>,
delete_keys: Mutex<Vec<String>>,
fail_get: AtomicBool,
fail_set: AtomicBool,
fail_delete: AtomicBool,
}
impl CountingMockDao {
fn new() -> Self {
Self {
store: Mutex::new(HashMap::new()),
get_count: AtomicU32::new(0),
set_count: AtomicU32::new(0),
delete_count: AtomicU32::new(0),
get_keys: Mutex::new(Vec::new()),
set_keys: Mutex::new(Vec::new()),
delete_keys: Mutex::new(Vec::new()),
fail_get: AtomicBool::new(false),
fail_set: AtomicBool::new(false),
fail_delete: AtomicBool::new(false),
}
}
fn get_count(&self) -> u32 {
self.get_count.load(Ordering::SeqCst)
}
fn set_count(&self) -> u32 {
self.set_count.load(Ordering::SeqCst)
}
fn delete_count(&self) -> u32 {
self.delete_count.load(Ordering::SeqCst)
}
fn get_keys(&self) -> Vec<String> {
self.get_keys.lock().clone()
}
fn set_keys(&self) -> Vec<String> {
self.set_keys.lock().clone()
}
fn delete_keys(&self) -> Vec<String> {
self.delete_keys.lock().clone()
}
fn insert_direct(&self, key: &str, value: &str) {
self.store.lock().insert(key.to_string(), value.to_string());
}
fn contains_key(&self, key: &str) -> bool {
self.store.lock().contains_key(key)
}
fn set_fail_get(&self, fail: bool) {
self.fail_get.store(fail, Ordering::SeqCst);
}
fn set_fail_set(&self, fail: bool) {
self.fail_set.store(fail, Ordering::SeqCst);
}
fn set_fail_delete(&self, fail: bool) {
self.fail_delete.store(fail, Ordering::SeqCst);
}
}
#[async_trait]
impl GarrisonDao for CountingMockDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
self.get_count.fetch_add(1, Ordering::SeqCst);
self.get_keys.lock().push(key.to_string());
if self.fail_get.load(Ordering::SeqCst) {
return Err(GarrisonError::Dao("injected get error".to_string()));
}
Ok(self.store.lock().get(key).cloned())
}
async fn set(&self, key: &str, value: &str, _ttl_seconds: u64) -> GarrisonResult<()> {
self.set_count.fetch_add(1, Ordering::SeqCst);
self.set_keys.lock().push(key.to_string());
if self.fail_set.load(Ordering::SeqCst) {
return Err(GarrisonError::Dao("injected set error".to_string()));
}
self.store.lock().insert(key.to_string(), value.to_string());
Ok(())
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
self.store.lock().insert(key.to_string(), value.to_string());
Ok(())
}
async fn expire(&self, _key: &str, _seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
self.delete_count.fetch_add(1, Ordering::SeqCst);
self.delete_keys.lock().push(key.to_string());
if self.fail_delete.load(Ordering::SeqCst) {
return Err(GarrisonError::Dao("injected delete error".to_string()));
}
self.store.lock().remove(key);
Ok(())
}
}
struct CountingMockInterface {
permissions: Mutex<HashMap<String, Vec<String>>>,
roles: Mutex<HashMap<String, Vec<String>>>,
user_info: Mutex<HashMap<String, Option<String>>>,
perm_count: AtomicU32,
role_count: AtomicU32,
user_count: AtomicU32,
fail_perm: AtomicBool,
fail_role: AtomicBool,
fail_user: AtomicBool,
}
impl CountingMockInterface {
fn new() -> Self {
Self {
permissions: Mutex::new(HashMap::new()),
roles: Mutex::new(HashMap::new()),
user_info: Mutex::new(HashMap::new()),
perm_count: AtomicU32::new(0),
role_count: AtomicU32::new(0),
user_count: AtomicU32::new(0),
fail_perm: AtomicBool::new(false),
fail_role: AtomicBool::new(false),
fail_user: AtomicBool::new(false),
}
}
fn set_permissions(&self, login_id: &str, perms: Vec<String>) {
self.permissions.lock().insert(login_id.to_string(), perms);
}
fn set_roles(&self, login_id: &str, roles: Vec<String>) {
self.roles.lock().insert(login_id.to_string(), roles);
}
fn set_user_info(&self, login_id: &str, info: Option<String>) {
self.user_info.lock().insert(login_id.to_string(), info);
}
fn perm_count(&self) -> u32 {
self.perm_count.load(Ordering::SeqCst)
}
fn role_count(&self) -> u32 {
self.role_count.load(Ordering::SeqCst)
}
fn user_count(&self) -> u32 {
self.user_count.load(Ordering::SeqCst)
}
fn set_fail_perm(&self, fail: bool) {
self.fail_perm.store(fail, Ordering::SeqCst);
}
fn set_fail_role(&self, fail: bool) {
self.fail_role.store(fail, Ordering::SeqCst);
}
fn set_fail_user(&self, fail: bool) {
self.fail_user.store(fail, Ordering::SeqCst);
}
}
#[async_trait]
impl GarrisonPermissionStrategy for CountingMockInterface {
async fn get_permission_list(&self, login_id: &str) -> GarrisonResult<Vec<String>> {
self.perm_count.fetch_add(1, Ordering::SeqCst);
if self.fail_perm.load(Ordering::SeqCst) {
return Err(GarrisonError::Internal("injected perm error".to_string()));
}
Ok(self
.permissions
.lock()
.get(login_id)
.cloned()
.unwrap_or_default())
}
async fn get_role_list(&self, login_id: &str) -> GarrisonResult<Vec<String>> {
self.role_count.fetch_add(1, Ordering::SeqCst);
if self.fail_role.load(Ordering::SeqCst) {
return Err(GarrisonError::Internal("injected role error".to_string()));
}
Ok(self.roles.lock().get(login_id).cloned().unwrap_or_default())
}
async fn check_permission(
&self,
_login_id: &str,
_permission: &str,
) -> GarrisonResult<bool> {
Ok(false)
}
async fn check_role(&self, _login_id: &str, _role: &str) -> GarrisonResult<bool> {
Ok(false)
}
async fn check_role_any(&self, _login_id: &str, _roles: &[&str]) -> GarrisonResult<bool> {
Ok(false)
}
async fn check_role_all(&self, _login_id: &str, _roles: &[&str]) -> GarrisonResult<bool> {
Ok(false)
}
async fn get_user_info(&self, login_id: &str) -> GarrisonResult<Option<String>> {
self.user_count.fetch_add(1, Ordering::SeqCst);
if self.fail_user.load(Ordering::SeqCst) {
return Err(GarrisonError::Internal("injected user error".to_string()));
}
Ok(self.user_info.lock().get(login_id).cloned().unwrap_or(None))
}
}
fn make_service(
l1_ttl_secs: u64,
l2_ttl_secs: u64,
) -> (
Arc<CountingMockDao>,
Arc<CountingMockInterface>,
UserCacheService,
) {
let dao = Arc::new(CountingMockDao::new());
let interface = Arc::new(CountingMockInterface::new());
let service = UserCacheService::new(
dao.clone() as Arc<dyn GarrisonDao>,
interface.clone() as Arc<dyn GarrisonPermissionStrategy>,
l1_ttl_secs,
l2_ttl_secs,
10_000,
)
.expect("UserCacheService::new 应成功");
(dao, interface, service)
}
fn make_default_service() -> (
Arc<CountingMockDao>,
Arc<CountingMockInterface>,
UserCacheService,
) {
make_service(30, 300)
}
#[tokio::test]
async fn l1_hit_does_not_query_l2_l3() {
let (dao, interface, service) = make_default_service();
interface.set_permissions("1001", vec!["user:read".to_string()]);
let perms1 = service.get_permissions("1001").await.unwrap();
assert_eq!(perms1, vec!["user:read".to_string()]);
assert_eq!(interface.perm_count(), 1, "第一次应查询 L3");
assert_eq!(dao.get_count(), 1, "第一次应查询 L2");
let perms2 = service.get_permissions("1001").await.unwrap();
assert_eq!(perms2, vec!["user:read".to_string()]);
assert_eq!(interface.perm_count(), 1, "L1 命中不应查询 L3");
assert_eq!(dao.get_count(), 1, "L1 命中不应查询 L2");
}
#[tokio::test]
async fn l1_miss_l2_hit_backfills_l1() {
let (dao, interface, service) = make_default_service();
let perms_json = serde_json::to_string(&vec!["admin:read".to_string()]).unwrap();
dao.insert_direct("perm:cache:2001", &perms_json);
let perms1 = service.get_permissions("2001").await.unwrap();
assert_eq!(perms1, vec!["admin:read".to_string()]);
assert_eq!(interface.perm_count(), 0, "L2 命中不应查询 L3");
assert_eq!(dao.get_count(), 1, "应查询 L2 一次");
let perms2 = service.get_permissions("2001").await.unwrap();
assert_eq!(perms2, vec!["admin:read".to_string()]);
assert_eq!(dao.get_count(), 1, "L1 回填后不应再查询 L2");
assert_eq!(interface.perm_count(), 0, "不应查询 L3");
}
#[tokio::test]
async fn l1_l2_miss_calls_l3_backfills_both() {
let (dao, interface, service) = make_default_service();
interface.set_permissions("3001", vec!["data:write".to_string()]);
let perms = service.get_permissions("3001").await.unwrap();
assert_eq!(perms, vec!["data:write".to_string()]);
assert_eq!(interface.perm_count(), 1, "应查询 L3 一次");
assert_eq!(dao.get_count(), 1, "应查询 L2 一次");
assert_eq!(dao.set_count(), 1, "应回填 L2 一次");
assert!(dao.contains_key("perm:cache:3001"), "L2 应已被回填");
let perms2 = service.get_permissions("3001").await.unwrap();
assert_eq!(perms2, vec!["data:write".to_string()]);
assert_eq!(interface.perm_count(), 1, "L1 回填后不应再查询 L3");
}
#[tokio::test]
async fn invalidate_clears_l1() {
let (_dao, interface, service) = make_default_service();
interface.set_permissions("4001", vec!["perm:a".to_string()]);
let _ = service.get_permissions("4001").await.unwrap();
assert_eq!(interface.perm_count(), 1);
service.invalidate("4001").await.unwrap();
let _ = service.get_permissions("4001").await.unwrap();
assert_eq!(interface.perm_count(), 2, "invalidate 后应重新查询 L3");
}
#[tokio::test]
async fn invalidate_clears_l2() {
let (dao, interface, service) = make_default_service();
interface.set_permissions("5001", vec!["perm:b".to_string()]);
let _ = service.get_permissions("5001").await.unwrap();
assert!(dao.contains_key("perm:cache:5001"), "L2 应已被回填");
service.invalidate("5001").await.unwrap();
assert!(
!dao.contains_key("perm:cache:5001"),
"invalidate 后 L2 应被清除"
);
assert!(
!dao.contains_key("role:cache:5001"),
"invalidate 后 L2 角色缓存应被清除"
);
assert!(
!dao.contains_key("user:cache:5001"),
"invalidate 后 L2 用户缓存应被清除"
);
assert_eq!(
dao.delete_count(),
3,
"invalidate 应执行 3 次 L2 delete(perm + role + user)"
);
}
#[tokio::test]
async fn get_permissions_uses_correct_key() {
let (dao, interface, service) = make_default_service();
interface.set_permissions("6001", vec!["perm:c".to_string()]);
let _ = service.get_permissions("6001").await.unwrap();
let set_keys = dao.set_keys();
assert!(
set_keys.iter().any(|k| k == "perm:cache:6001"),
"set 应使用 key 'perm:cache:6001',实际: {:?}",
set_keys
);
let get_keys = dao.get_keys();
assert!(
get_keys.iter().any(|k| k == "perm:cache:6001"),
"get 应使用 key 'perm:cache:6001',实际: {:?}",
get_keys
);
}
#[tokio::test]
async fn get_roles_uses_correct_key() {
let (dao, interface, service) = make_default_service();
interface.set_roles("7001", vec!["admin".to_string()]);
let _ = service.get_roles("7001").await.unwrap();
let set_keys = dao.set_keys();
assert!(
set_keys.iter().any(|k| k == "role:cache:7001"),
"set 应使用 key 'role:cache:7001',实际: {:?}",
set_keys
);
let get_keys = dao.get_keys();
assert!(
get_keys.iter().any(|k| k == "role:cache:7001"),
"get 应使用 key 'role:cache:7001',实际: {:?}",
get_keys
);
}
#[tokio::test]
async fn get_user_uses_correct_key() {
let (dao, interface, service) = make_default_service();
interface.set_user_info("8001", Some(r#"{"name":"alice"}"#.to_string()));
let _ = service.get_user("8001").await.unwrap();
let set_keys = dao.set_keys();
assert!(
set_keys.iter().any(|k| k == "user:cache:8001"),
"set 应使用 key 'user:cache:8001',实际: {:?}",
set_keys
);
let get_keys = dao.get_keys();
assert!(
get_keys.iter().any(|k| k == "user:cache:8001"),
"get 应使用 key 'user:cache:8001',实际: {:?}",
get_keys
);
}
#[tokio::test]
async fn get_user_returns_none_when_not_found() {
let (dao, interface, service) = make_default_service();
let result = service.get_user("9001").await.unwrap();
assert!(result.is_none(), "用户不存在时应返回 Ok(None)");
assert_eq!(interface.user_count(), 1, "应查询 L3 一次");
assert!(!dao.contains_key("user:cache:9001"), "None 不应缓存到 L2");
assert_eq!(dao.set_count(), 0, "None 不应触发 L2 set 操作");
let result2 = service.get_user("9001").await.unwrap();
assert!(result2.is_none());
assert_eq!(
interface.user_count(),
2,
"未缓存 None,第二次应再次查询 L3"
);
}
#[tokio::test]
async fn ttl_expires_l1() {
let (_dao, interface, service) = make_service(1, 300);
interface.set_permissions("10001", vec!["perm:d".to_string()]);
let _ = service.get_permissions("10001").await.unwrap();
assert_eq!(interface.perm_count(), 1, "第一次应查询 L3");
tokio::time::sleep(Duration::from_secs(2)).await;
let perms = service.get_permissions("10001").await.unwrap();
assert_eq!(perms, vec!["perm:d".to_string()]);
assert_eq!(interface.perm_count(), 1, "L1 过期后 L2 命中,不应查询 L3");
}
#[tokio::test]
async fn invalidate_nonexistent_key_is_idempotent() {
let (_dao, _interface, service) = make_default_service();
let result = service.invalidate("nonexistent_user").await;
assert!(result.is_ok(), "invalidate 不存在的 key 应幂等返回 Ok(())");
}
#[tokio::test(flavor = "multi_thread")]
async fn concurrent_backfill_no_conflict() {
let dao = Arc::new(CountingMockDao::new());
let interface = Arc::new(CountingMockInterface::new());
interface.set_permissions("11001", vec!["perm:e".to_string()]);
let service = Arc::new(
UserCacheService::new(
dao.clone() as Arc<dyn GarrisonDao>,
interface.clone() as Arc<dyn GarrisonPermissionStrategy>,
30,
300,
10_000,
)
.expect("UserCacheService::new 应成功"),
);
let mut handles = Vec::new();
for _ in 0..10 {
let s = service.clone();
handles.push(tokio::spawn(
async move { s.get_permissions("11001").await },
));
}
let mut success = 0;
for handle in handles {
let result = handle.await.expect("task panicked");
match result {
Ok(perms) => {
assert_eq!(
perms,
vec!["perm:e".to_string()],
"所有并发调用应返回相同结果"
);
success += 1;
},
Err(e) => panic!("并发回填不应失败: {:?}", e),
}
}
assert_eq!(success, 10, "所有 10 个并发调用应成功");
}
#[tokio::test]
async fn logout_invalidates_cache() {
let (dao, interface, service) = make_default_service();
interface.set_permissions("12001", vec!["perm:f".to_string()]);
interface.set_roles("12001", vec!["user".to_string()]);
interface.set_user_info("12001", Some(r#"{"id":12001}"#.to_string()));
let _ = service.get_permissions("12001").await.unwrap();
let _ = service.get_roles("12001").await.unwrap();
let _ = service.get_user("12001").await.unwrap();
assert_eq!(interface.perm_count(), 1);
assert_eq!(interface.role_count(), 1);
assert_eq!(interface.user_count(), 1);
assert!(dao.contains_key("perm:cache:12001"));
assert!(dao.contains_key("role:cache:12001"));
assert!(dao.contains_key("user:cache:12001"));
service.invalidate("12001").await.unwrap();
assert!(!dao.contains_key("perm:cache:12001"));
assert!(!dao.contains_key("role:cache:12001"));
assert!(!dao.contains_key("user:cache:12001"));
let _ = service.get_permissions("12001").await.unwrap();
let _ = service.get_roles("12001").await.unwrap();
let _ = service.get_user("12001").await.unwrap();
assert_eq!(interface.perm_count(), 2, "登出后权限缓存应走 L3");
assert_eq!(interface.role_count(), 2, "登出后角色缓存应走 L3");
assert_eq!(interface.user_count(), 2, "登出后用户缓存应走 L3");
}
#[tokio::test]
async fn permission_change_invalidates_cache() {
let (_dao, interface, service) = make_default_service();
interface.set_permissions("13001", vec!["old:perm".to_string()]);
let perms1 = service.get_permissions("13001").await.unwrap();
assert_eq!(perms1, vec!["old:perm".to_string()]);
interface.set_permissions("13001", vec!["new:perm".to_string()]);
let perms2 = service.get_permissions("13001").await.unwrap();
assert_eq!(
perms2,
vec!["old:perm".to_string()],
"未 invalidate 时应返回缓存的旧权限"
);
service.invalidate("13001").await.unwrap();
let perms3 = service.get_permissions("13001").await.unwrap();
assert_eq!(
perms3,
vec!["new:perm".to_string()],
"invalidate 后应返回新权限"
);
}
#[tokio::test]
async fn logout_then_relogin_uses_l3() {
let (dao, interface, service) = make_default_service();
interface.set_permissions("14001", vec!["perm:g".to_string()]);
let _ = service.get_permissions("14001").await.unwrap();
assert_eq!(interface.perm_count(), 1, "首次登录应查询 L3");
assert!(dao.contains_key("perm:cache:14001"));
service.invalidate("14001").await.unwrap();
assert!(!dao.contains_key("perm:cache:14001"));
let _ = service.get_permissions("14001").await.unwrap();
assert_eq!(interface.perm_count(), 2, "登出后再次登录应走 L3");
assert_eq!(
dao.get_count(),
2,
"应查询 L2 两次(首次填充 miss + 登出后再次查询 miss)"
);
}
#[test]
fn default_config_includes_cache_settings() {
let config = crate::config::GarrisonConfig::default_config();
assert_eq!(
config.l1_cache_ttl_secs,
crate::config::DEFAULT_L1_CACHE_TTL_SECS
);
assert_eq!(
config.l2_cache_ttl_secs,
crate::config::DEFAULT_L2_CACHE_TTL_SECS
);
assert_eq!(
config.l1_cache_capacity,
crate::config::DEFAULT_L1_CACHE_CAPACITY
);
}
#[test]
fn validate_rejects_zero_l1_cache_ttl() {
let mut config = crate::config::GarrisonConfig::default_config();
config.l1_cache_ttl_secs = 0;
let result = config.validate();
assert!(result.is_err(), "l1_cache_ttl_secs=0 应校验失败");
}
#[test]
fn validate_rejects_zero_l2_cache_ttl() {
let mut config = crate::config::GarrisonConfig::default_config();
config.l2_cache_ttl_secs = 0;
let result = config.validate();
assert!(result.is_err(), "l2_cache_ttl_secs=0 应校验失败");
}
#[test]
fn validate_rejects_zero_l1_cache_capacity() {
let mut config = crate::config::GarrisonConfig::default_config();
config.l1_cache_capacity = 0;
let result = config.validate();
assert!(result.is_err(), "l1_cache_capacity=0 应校验失败");
}
#[tokio::test(flavor = "multi_thread")]
async fn singleflight_prevents_cache_stampede() {
let dao = Arc::new(CountingMockDao::new());
let interface = Arc::new(CountingMockInterface::new());
interface.set_permissions("13001", vec!["perm:sf".to_string()]);
let service = Arc::new(
UserCacheService::new(
dao.clone() as Arc<dyn GarrisonDao>,
interface.clone() as Arc<dyn GarrisonPermissionStrategy>,
30,
300,
10_000,
)
.expect("UserCacheService::new 应成功"),
);
let mut handles = Vec::new();
for _ in 0..10 {
let s = service.clone();
handles.push(tokio::spawn(
async move { s.get_permissions("13001").await },
));
}
for handle in handles {
let perms = handle.await.expect("task panicked").expect("应成功");
assert_eq!(perms, vec!["perm:sf".to_string()]);
}
assert_eq!(
interface.perm_count(),
1,
"singleflight 应保证并发请求同一 key 时只触发一次 L3 加载,实际: {}",
interface.perm_count()
);
}
#[tokio::test(flavor = "multi_thread")]
async fn singleflight_different_keys_no_blocking() {
let dao = Arc::new(CountingMockDao::new());
let interface = Arc::new(CountingMockInterface::new());
for i in 0..10 {
let login_id = format!("1400{}", i);
interface.set_permissions(&login_id, vec![format!("perm:{}", i)]);
}
let service = Arc::new(
UserCacheService::new(
dao.clone() as Arc<dyn GarrisonDao>,
interface.clone() as Arc<dyn GarrisonPermissionStrategy>,
30,
300,
10_000,
)
.expect("UserCacheService::new 应成功"),
);
let mut handles = Vec::new();
for i in 0..10u32 {
let s = service.clone();
handles.push(tokio::spawn(async move {
let login_id = format!("1400{}", i);
s.get_permissions(&login_id).await
}));
}
for (i, handle) in handles.into_iter().enumerate() {
let perms = handle.await.expect("task panicked").expect("应成功");
assert_eq!(perms, vec![format!("perm:{}", i)]);
}
assert_eq!(
interface.perm_count(),
10,
"不同 key 应独立加载,L3 应被调用 10 次,实际: {}",
interface.perm_count()
);
}
#[tokio::test(flavor = "multi_thread")]
async fn singleflight_protects_get_roles() {
let dao = Arc::new(CountingMockDao::new());
let interface = Arc::new(CountingMockInterface::new());
interface.set_roles("15001", vec!["admin".to_string()]);
let service = Arc::new(
UserCacheService::new(
dao.clone() as Arc<dyn GarrisonDao>,
interface.clone() as Arc<dyn GarrisonPermissionStrategy>,
30,
300,
10_000,
)
.expect("UserCacheService::new 应成功"),
);
let mut handles = Vec::new();
for _ in 0..10 {
let s = service.clone();
handles.push(tokio::spawn(async move { s.get_roles("15001").await }));
}
for handle in handles {
let roles = handle.await.expect("task panicked").expect("应成功");
assert_eq!(roles, vec!["admin".to_string()]);
}
assert_eq!(
interface.role_count(),
1,
"singleflight 应保证 get_roles 并发时只触发一次 L3 加载"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn singleflight_protects_get_user() {
let dao = Arc::new(CountingMockDao::new());
let interface = Arc::new(CountingMockInterface::new());
interface.set_user_info("16001", Some(r#"{"id":16001}"#.to_string()));
let service = Arc::new(
UserCacheService::new(
dao.clone() as Arc<dyn GarrisonDao>,
interface.clone() as Arc<dyn GarrisonPermissionStrategy>,
30,
300,
10_000,
)
.expect("UserCacheService::new 应成功"),
);
let mut handles = Vec::new();
for _ in 0..10 {
let s = service.clone();
handles.push(tokio::spawn(async move { s.get_user("16001").await }));
}
for handle in handles {
let user = handle.await.expect("task panicked").expect("应成功");
assert_eq!(user, Some(r#"{"id":16001}"#.to_string()));
}
assert_eq!(
interface.user_count(),
1,
"singleflight 应保证 get_user 并发时只触发一次 L3 加载"
);
}
#[tokio::test]
async fn get_roles_l1_hit_does_not_query_l2_l3() {
let (dao, interface, service) = make_default_service();
interface.set_roles("17001", vec!["admin".to_string()]);
let roles1 = service.get_roles("17001").await.unwrap();
assert_eq!(roles1, vec!["admin".to_string()]);
assert_eq!(interface.role_count(), 1, "第一次应查询 L3");
assert_eq!(dao.get_count(), 1, "第一次应查询 L2");
let roles2 = service.get_roles("17001").await.unwrap();
assert_eq!(roles2, vec!["admin".to_string()]);
assert_eq!(interface.role_count(), 1, "L1 命中不应查询 L3");
assert_eq!(dao.get_count(), 1, "L1 命中不应查询 L2");
}
#[tokio::test]
async fn get_roles_l1_miss_l2_hit_backfills_l1() {
let (dao, interface, service) = make_default_service();
let roles_json = serde_json::to_string(&vec!["editor".to_string()]).unwrap();
dao.insert_direct("role:cache:18001", &roles_json);
let roles1 = service.get_roles("18001").await.unwrap();
assert_eq!(roles1, vec!["editor".to_string()]);
assert_eq!(interface.role_count(), 0, "L2 命中不应查询 L3");
assert_eq!(dao.get_count(), 1, "应查询 L2 一次");
let roles2 = service.get_roles("18001").await.unwrap();
assert_eq!(roles2, vec!["editor".to_string()]);
assert_eq!(dao.get_count(), 1, "L1 回填后不应再查询 L2");
assert_eq!(interface.role_count(), 0, "不应查询 L3");
}
#[tokio::test]
async fn get_user_l1_hit_does_not_query_l2_l3() {
let (dao, interface, service) = make_default_service();
interface.set_user_info("19001", Some(r#"{"name":"alice"}"#.to_string()));
let user1 = service.get_user("19001").await.unwrap();
assert_eq!(user1, Some(r#"{"name":"alice"}"#.to_string()));
assert_eq!(interface.user_count(), 1, "第一次应查询 L3");
assert_eq!(dao.get_count(), 1, "第一次应查询 L2");
let user2 = service.get_user("19001").await.unwrap();
assert_eq!(user2, Some(r#"{"name":"alice"}"#.to_string()));
assert_eq!(interface.user_count(), 1, "L1 命中不应查询 L3");
assert_eq!(dao.get_count(), 1, "L1 命中不应查询 L2");
}
#[tokio::test]
async fn get_user_l1_miss_l2_hit_backfills_l1() {
let (dao, interface, service) = make_default_service();
dao.insert_direct("user:cache:20001", r#"{"id":20001}"#);
let user1 = service.get_user("20001").await.unwrap();
assert_eq!(user1, Some(r#"{"id":20001}"#.to_string()));
assert_eq!(interface.user_count(), 0, "L2 命中不应查询 L3");
assert_eq!(dao.get_count(), 1, "应查询 L2 一次");
let user2 = service.get_user("20001").await.unwrap();
assert_eq!(user2, Some(r#"{"id":20001}"#.to_string()));
assert_eq!(dao.get_count(), 1, "L1 回填后不应再查询 L2");
assert_eq!(interface.user_count(), 0, "不应查询 L3");
}
#[tokio::test]
async fn get_user_l3_some_backfills_l1_and_l2() {
let (dao, interface, service) = make_default_service();
interface.set_user_info("21001", Some(r#"{"id":21001}"#.to_string()));
let user = service.get_user("21001").await.unwrap();
assert_eq!(user, Some(r#"{"id":21001}"#.to_string()));
assert_eq!(interface.user_count(), 1, "应查询 L3 一次");
assert_eq!(dao.get_count(), 1, "应查询 L2 一次");
assert_eq!(dao.set_count(), 1, "应回填 L2 一次");
assert!(dao.contains_key("user:cache:21001"), "L2 应已被回填");
let user2 = service.get_user("21001").await.unwrap();
assert_eq!(user2, Some(r#"{"id":21001}"#.to_string()));
assert_eq!(interface.user_count(), 1, "L1 回填后不应再查询 L3");
}
#[tokio::test]
async fn l2_corrupt_permission_cache_returns_internal_error() {
let (dao, _interface, service) = make_default_service();
dao.insert_direct("perm:cache:22001", "{invalid json");
let result = service.get_permissions("22001").await;
assert!(result.is_err(), "L2 缓存损坏应返回 Err");
match result {
Err(GarrisonError::Internal(msg)) => {
assert!(
msg.contains("cache-l2-perm-deser"),
"错误消息应包含 'L2 权限缓存反序列化失败',实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Internal,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
}
#[tokio::test]
async fn l3_failure_propagates_error() {
let (_dao, interface, service) = make_default_service();
interface.set_fail_perm(true);
let result = service.get_permissions("23001").await;
assert!(result.is_err(), "L3 权限失败应返回 Err");
match result {
Err(GarrisonError::Internal(msg)) => {
assert!(
msg.contains("injected perm error"),
"应透传 L3 权限错误消息,实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Internal,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
interface.set_fail_role(true);
let result = service.get_roles("23002").await;
assert!(result.is_err(), "L3 角色失败应返回 Err");
match result {
Err(GarrisonError::Internal(msg)) => {
assert!(
msg.contains("injected role error"),
"应透传 L3 角色错误消息,实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Internal,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
interface.set_fail_user(true);
let result = service.get_user("23003").await;
assert!(result.is_err(), "L3 用户失败应返回 Err");
match result {
Err(GarrisonError::Internal(msg)) => {
assert!(
msg.contains("injected user error"),
"应透传 L3 用户错误消息,实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Internal,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
}
#[tokio::test]
async fn l2_dao_failure_propagates_error() {
let (dao, _interface, service) = make_default_service();
dao.set_fail_get(true);
let result = service.get_permissions("24001").await;
assert!(result.is_err(), "L2 DAO get 失败应返回 Err");
match result {
Err(GarrisonError::Dao(msg)) => {
assert!(
msg.contains("injected get error"),
"应透传 DAO get 错误消息,实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Dao,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
let (dao2, interface2, service2) = make_default_service();
interface2.set_permissions("24002", vec!["perm:set_fail".to_string()]);
dao2.set_fail_set(true);
let result = service2.get_permissions("24002").await;
assert!(result.is_err(), "L2 DAO set 失败应返回 Err");
match result {
Err(GarrisonError::Dao(msg)) => {
assert!(
msg.contains("injected set error"),
"应透传 DAO set 错误消息,实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Dao,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
}
#[tokio::test]
async fn invalidate_l2_delete_failure_propagates_error() {
let (dao, _interface, service) = make_default_service();
dao.set_fail_delete(true);
let result = service.invalidate("25001").await;
assert!(result.is_err(), "L2 delete 失败应返回 Err");
match result {
Err(GarrisonError::Dao(msg)) => {
assert!(
msg.contains("injected delete error"),
"应透传 DAO delete 错误消息,实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Dao,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
assert!(
dao.delete_count() >= 1,
"应至少调用一次 L2 delete,实际: {}",
dao.delete_count()
);
}
#[test]
fn ttl_getters_return_configured_values() {
let (_dao, _interface, service) = make_service(60, 600);
assert_eq!(service.l1_ttl_secs(), 60, "l1_ttl_secs 应返回 60");
assert_eq!(service.l2_ttl_secs(), 600, "l2_ttl_secs 应返回 600");
}
#[tokio::test]
async fn l1_corrupt_permission_cache_returns_internal_error() {
let (_dao, _interface, service) = make_default_service();
let key = "perm:cache:27001".to_string();
let bad_value = "{invalid json".to_string();
service
.l1
.set_with_ttl(&key, &bad_value, Some(Duration::from_secs(30)))
.await
.expect("向 L1 注入损坏数据应成功");
let result = service.get_permissions("27001").await;
assert!(result.is_err(), "L1 缓存损坏应返回 Err");
match result {
Err(GarrisonError::Internal(msg)) => {
assert!(
msg.contains("cache-l1-perm-deser"),
"错误消息应包含 'L1 权限缓存反序列化失败',实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Internal,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
}
#[tokio::test]
async fn l1_corrupt_role_cache_returns_internal_error() {
let (_dao, _interface, service) = make_default_service();
let key = "role:cache:28001".to_string();
let bad_value = "{invalid json".to_string();
service
.l1
.set_with_ttl(&key, &bad_value, Some(Duration::from_secs(30)))
.await
.expect("向 L1 注入损坏数据应成功");
let result = service.get_roles("28001").await;
assert!(result.is_err(), "L1 缓存损坏应返回 Err");
match result {
Err(GarrisonError::Internal(msg)) => {
assert!(
msg.contains("cache-l1-role-deser"),
"错误消息应包含 'L1 角色缓存反序列化失败',实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Internal,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
}
#[tokio::test]
async fn l2_corrupt_role_cache_returns_internal_error() {
let (dao, _interface, service) = make_default_service();
dao.insert_direct("role:cache:29001", "{invalid json");
let result = service.get_roles("29001").await;
assert!(result.is_err(), "L2 缓存损坏应返回 Err");
match result {
Err(GarrisonError::Internal(msg)) => {
assert!(
msg.contains("cache-l2-role-deser"),
"错误消息应包含 'L2 角色缓存反序列化失败',实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Internal,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
}
#[tokio::test]
async fn invalidate_clears_l1_for_roles() {
let (_dao, interface, service) = make_default_service();
interface.set_roles("30001", vec!["admin".to_string()]);
let _ = service.get_roles("30001").await.unwrap();
assert_eq!(interface.role_count(), 1, "第一次应查询 L3");
service.invalidate("30001").await.unwrap();
let _ = service.get_roles("30001").await.unwrap();
assert_eq!(interface.role_count(), 2, "invalidate 后应重新查询 L3");
}
#[tokio::test]
async fn invalidate_clears_l1_for_user() {
let (_dao, interface, service) = make_default_service();
interface.set_user_info("31001", Some(r#"{"id":31001}"#.to_string()));
let _ = service.get_user("31001").await.unwrap();
assert_eq!(interface.user_count(), 1, "第一次应查询 L3");
service.invalidate("31001").await.unwrap();
let _ = service.get_user("31001").await.unwrap();
assert_eq!(interface.user_count(), 2, "invalidate 后应重新查询 L3");
}
#[tokio::test]
async fn get_roles_l3_backfills_l1_and_l2() {
let (dao, interface, service) = make_default_service();
interface.set_roles("32001", vec!["editor".to_string()]);
let roles = service.get_roles("32001").await.unwrap();
assert_eq!(roles, vec!["editor".to_string()]);
assert_eq!(interface.role_count(), 1, "应查询 L3 一次");
assert_eq!(dao.get_count(), 1, "应查询 L2 一次");
assert_eq!(dao.set_count(), 1, "应回填 L2 一次");
assert!(dao.contains_key("role:cache:32001"), "L2 应已被回填");
let roles2 = service.get_roles("32001").await.unwrap();
assert_eq!(roles2, vec!["editor".to_string()]);
assert_eq!(interface.role_count(), 1, "L1 回填后不应再查询 L3");
}
#[tokio::test]
async fn get_permissions_returns_empty_vec() {
let (dao, interface, service) = make_default_service();
let perms = service.get_permissions("33001").await.unwrap();
assert!(perms.is_empty(), "未设置权限时应返回空列表");
assert_eq!(interface.perm_count(), 1, "应查询 L3 一次");
assert_eq!(dao.set_count(), 1, "空列表也应回填 L2");
}
#[tokio::test]
async fn get_roles_returns_empty_vec() {
let (dao, interface, service) = make_default_service();
let roles = service.get_roles("34001").await.unwrap();
assert!(roles.is_empty(), "未设置角色时应返回空列表");
assert_eq!(interface.role_count(), 1, "应查询 L3 一次");
assert_eq!(dao.set_count(), 1, "空列表也应回填 L2");
}
#[tokio::test]
async fn ttl_expires_l1_for_roles() {
let (_dao, interface, service) = make_service(1, 300);
interface.set_roles("35001", vec!["admin".to_string()]);
let _ = service.get_roles("35001").await.unwrap();
assert_eq!(interface.role_count(), 1, "第一次应查询 L3");
tokio::time::sleep(Duration::from_secs(2)).await;
let roles = service.get_roles("35001").await.unwrap();
assert_eq!(roles, vec!["admin".to_string()]);
assert_eq!(interface.role_count(), 1, "L1 过期后 L2 命中,不应查询 L3");
}
#[tokio::test]
async fn ttl_expires_l1_for_user() {
let (_dao, interface, service) = make_service(1, 300);
interface.set_user_info("36001", Some(r#"{"id":36001}"#.to_string()));
let _ = service.get_user("36001").await.unwrap();
assert_eq!(interface.user_count(), 1, "第一次应查询 L3");
tokio::time::sleep(Duration::from_secs(2)).await;
let user = service.get_user("36001").await.unwrap();
assert_eq!(user, Some(r#"{"id":36001}"#.to_string()));
assert_eq!(interface.user_count(), 1, "L1 过期后 L2 命中,不应查询 L3");
}
#[tokio::test]
async fn l2_dao_get_failure_propagates_error_for_get_roles() {
let (dao, _interface, service) = make_default_service();
dao.set_fail_get(true);
let result = service.get_roles("37001").await;
assert!(result.is_err(), "L2 DAO get 失败应返回 Err");
match result {
Err(GarrisonError::Dao(msg)) => {
assert!(
msg.contains("injected get error"),
"应透传 DAO get 错误消息,实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Dao,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
}
#[tokio::test]
async fn l2_dao_get_failure_propagates_error_for_get_user() {
let (dao, _interface, service) = make_default_service();
dao.set_fail_get(true);
let result = service.get_user("38001").await;
assert!(result.is_err(), "L2 DAO get 失败应返回 Err");
match result {
Err(GarrisonError::Dao(msg)) => {
assert!(
msg.contains("injected get error"),
"应透传 DAO get 错误消息,实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Dao,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
}
#[tokio::test]
async fn l2_dao_set_failure_propagates_error_for_get_roles() {
let (dao, interface, service) = make_default_service();
interface.set_roles("39001", vec!["editor".to_string()]);
dao.set_fail_set(true);
let result = service.get_roles("39001").await;
assert!(result.is_err(), "L2 DAO set 失败应返回 Err");
match result {
Err(GarrisonError::Dao(msg)) => {
assert!(
msg.contains("injected set error"),
"应透传 DAO set 错误消息,实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Dao,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
}
#[tokio::test]
async fn l2_dao_set_failure_propagates_error_for_get_user_some() {
let (dao, interface, service) = make_default_service();
interface.set_user_info("40001", Some(r#"{"id":40001}"#.to_string()));
dao.set_fail_set(true);
let result = service.get_user("40001").await;
assert!(result.is_err(), "L2 DAO set 失败应返回 Err");
match result {
Err(GarrisonError::Dao(msg)) => {
assert!(
msg.contains("injected set error"),
"应透传 DAO set 错误消息,实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Dao,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
}
#[tokio::test]
async fn l2_dao_set_failure_does_not_affect_get_user_none() {
let (dao, _interface, service) = make_default_service();
dao.set_fail_set(true);
let result = service.get_user("41001").await;
assert!(
result.is_ok(),
"get_user(None) 不应受 L2 set 失败影响,实际: {:?}",
result
);
assert!(result.unwrap().is_none());
assert_eq!(dao.set_count(), 0, "None 不应触发 L2 set 操作");
}
#[tokio::test]
async fn invalidate_partial_l2_delete_failure_propagates_error() {
let (dao, interface, service) = make_default_service();
interface.set_permissions("42001", vec!["perm:a".to_string()]);
interface.set_roles("42001", vec!["role:a".to_string()]);
interface.set_user_info("42001", Some(r#"{"id":42001}"#.to_string()));
let _ = service.get_permissions("42001").await.unwrap();
let _ = service.get_roles("42001").await.unwrap();
let _ = service.get_user("42001").await.unwrap();
assert!(dao.contains_key("perm:cache:42001"));
assert!(dao.contains_key("role:cache:42001"));
assert!(dao.contains_key("user:cache:42001"));
dao.set_fail_delete(true);
let result = service.invalidate("42001").await;
assert!(result.is_err(), "L2 delete 失败应返回 Err");
match result {
Err(GarrisonError::Dao(msg)) => {
assert!(
msg.contains("injected delete error"),
"应透传 DAO delete 错误消息,实际: {}",
msg
);
},
Err(other) => panic!("期望 GarrisonError::Dao,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
assert_eq!(
dao.delete_count(),
1,
"perm_key delete 应已执行,后续 delete 应在错误后中断"
);
}
#[tokio::test]
async fn invalidate_executes_all_l2_and_l1_deletes() {
let (dao, interface, service) = make_default_service();
interface.set_permissions("43001", vec!["perm:a".to_string()]);
interface.set_roles("43001", vec!["role:a".to_string()]);
interface.set_user_info("43001", Some(r#"{"id":43001}"#.to_string()));
let _ = service.get_permissions("43001").await.unwrap();
let _ = service.get_roles("43001").await.unwrap();
let _ = service.get_user("43001").await.unwrap();
assert!(dao.contains_key("perm:cache:43001"));
assert!(dao.contains_key("role:cache:43001"));
assert!(dao.contains_key("user:cache:43001"));
service.invalidate("43001").await.unwrap();
assert!(!dao.contains_key("perm:cache:43001"));
assert!(!dao.contains_key("role:cache:43001"));
assert!(!dao.contains_key("user:cache:43001"));
assert_eq!(
dao.delete_count(),
3,
"invalidate 应执行 3 次 L2 delete(perm + role + user)"
);
let delete_keys = dao.delete_keys();
assert_eq!(delete_keys.len(), 3, "应记录 3 次 delete 调用");
assert_eq!(
delete_keys[0], "perm:cache:43001",
"第一个 delete 应为 perm_key"
);
assert_eq!(
delete_keys[1], "role:cache:43001",
"第二个 delete 应为 role_key"
);
assert_eq!(
delete_keys[2], "user:cache:43001",
"第三个 delete 应为 user_key"
);
}
#[tokio::test]
async fn get_user_l3_some_empty_string_is_cached() {
let (dao, interface, service) = make_default_service();
interface.set_user_info("44001", Some(String::new()));
let user = service.get_user("44001").await.unwrap();
assert_eq!(user, Some(String::new()), "L3 返回 Some(\"\") 应透传");
assert_eq!(interface.user_count(), 1, "应查询 L3 一次");
assert_eq!(dao.set_count(), 1, "Some(\"\") 应回填 L2");
assert!(
dao.contains_key("user:cache:44001"),
"Some(\"\") 应被缓存到 L2"
);
let user2 = service.get_user("44001").await.unwrap();
assert_eq!(user2, Some(String::new()));
assert_eq!(interface.user_count(), 1, "L1 命中不应查询 L3");
}
#[tokio::test]
async fn get_user_l2_hit_returns_raw_string_without_deserialization() {
let (dao, _interface, service) = make_default_service();
dao.insert_direct("user:cache:45001", "not-a-json-string");
let user = service.get_user("45001").await.unwrap();
assert_eq!(
user,
Some("not-a-json-string".to_string()),
"get_user 应原样返回 L2 中的字符串,不做反序列化"
);
}
#[tokio::test]
async fn get_permissions_handles_special_chars_in_login_id() {
let (dao, interface, service) = make_default_service();
interface.set_permissions("user:1001.v2", vec!["perm:special".to_string()]);
let perms = service.get_permissions("user:1001.v2").await.unwrap();
assert_eq!(perms, vec!["perm:special".to_string()]);
let set_keys = dao.set_keys();
assert!(
set_keys.iter().any(|k| k == "perm:cache:user:1001.v2"),
"缓存键应包含原始 login_id,实际: {:?}",
set_keys
);
let perms2 = service.get_permissions("user:1001.v2").await.unwrap();
assert_eq!(perms2, vec!["perm:special".to_string()]);
assert_eq!(interface.perm_count(), 1, "L1 命中不应查询 L3");
}
#[tokio::test]
async fn invalidate_handles_special_chars_in_login_id() {
let (dao, interface, service) = make_default_service();
interface.set_permissions("user:2001.v2", vec!["perm:a".to_string()]);
let _ = service.get_permissions("user:2001.v2").await.unwrap();
assert!(dao.contains_key("perm:cache:user:2001.v2"));
service.invalidate("user:2001.v2").await.unwrap();
assert!(!dao.contains_key("perm:cache:user:2001.v2"));
let delete_keys = dao.delete_keys();
assert!(
delete_keys.iter().any(|k| k == "perm:cache:user:2001.v2"),
"delete 应使用 key 'perm:cache:user:2001.v2',实际: {:?}",
delete_keys
);
}
#[tokio::test]
async fn singleflight_lock_returns_same_lock_for_same_key() {
let (_dao, _interface, service) = make_default_service();
let lock1 = service.singleflight_lock("test-key-1");
let lock2 = service.singleflight_lock("test-key-1");
assert!(
Arc::ptr_eq(&lock1, &lock2),
"同一 key 的 singleflight_lock 应返回同一 Arc<RwLock>"
);
let lock3 = service.singleflight_lock("test-key-2");
assert!(
!Arc::ptr_eq(&lock1, &lock3),
"不同 key 的 singleflight_lock 应返回不同 Arc<RwLock>"
);
}
#[tokio::test]
async fn new_accepts_zero_l1_capacity() {
let dao = Arc::new(CountingMockDao::new());
let interface = Arc::new(CountingMockInterface::new());
let service = UserCacheService::new(
dao.clone() as Arc<dyn GarrisonDao>,
interface.clone() as Arc<dyn GarrisonPermissionStrategy>,
30,
300,
0, );
assert!(service.is_ok(), "l1_capacity=0 应成功创建 service");
interface.set_permissions("49001", vec!["perm:a".to_string()]);
let perms = service.unwrap().get_permissions("49001").await.unwrap();
assert_eq!(perms, vec!["perm:a".to_string()]);
}
#[tokio::test]
async fn new_stores_ttl_values_correctly() {
let dao = Arc::new(CountingMockDao::new());
let interface = Arc::new(CountingMockInterface::new());
let service = UserCacheService::new(
dao.clone() as Arc<dyn GarrisonDao>,
interface.clone() as Arc<dyn GarrisonPermissionStrategy>,
120,
3600,
10_000,
)
.unwrap();
assert_eq!(service.l1_ttl_secs(), 120, "l1_ttl_secs 应为 120");
assert_eq!(service.l2_ttl_secs(), 3600, "l2_ttl_secs 应为 3600");
}
#[tokio::test]
async fn get_permissions_l3_empty_vec_backfills_both_layers() {
let (dao, interface, service) = make_default_service();
let perms = service.get_permissions("51001").await.unwrap();
assert!(perms.is_empty(), "未设置权限时应返回空列表");
assert_eq!(interface.perm_count(), 1, "应查询 L3 一次");
assert_eq!(dao.set_count(), 1, "空 Vec 也应回填 L2");
assert!(dao.contains_key("perm:cache:51001"), "空 Vec 应被缓存到 L2");
let perms2 = service.get_permissions("51001").await.unwrap();
assert!(perms2.is_empty());
assert_eq!(interface.perm_count(), 1, "L1 回填后不应再查询 L3");
}
#[tokio::test]
async fn get_roles_l3_empty_vec_backfills_both_layers() {
let (dao, interface, service) = make_default_service();
let roles = service.get_roles("52001").await.unwrap();
assert!(roles.is_empty(), "未设置角色时应返回空列表");
assert_eq!(interface.role_count(), 1, "应查询 L3 一次");
assert_eq!(dao.set_count(), 1, "空 Vec 也应回填 L2");
assert!(dao.contains_key("role:cache:52001"), "空 Vec 应被缓存到 L2");
let roles2 = service.get_roles("52001").await.unwrap();
assert!(roles2.is_empty());
assert_eq!(interface.role_count(), 1, "L1 回填后不应再查询 L3");
}
#[tokio::test]
async fn invalidate_then_get_returns_fresh_data() {
let (_dao, interface, service) = make_default_service();
interface.set_permissions("53001", vec!["old:perm".to_string()]);
let perms1 = service.get_permissions("53001").await.unwrap();
assert_eq!(perms1, vec!["old:perm".to_string()]);
interface.set_permissions("53001", vec!["new:perm".to_string()]);
service.invalidate("53001").await.unwrap();
let perms2 = service.get_permissions("53001").await.unwrap();
assert_eq!(
perms2,
vec!["new:perm".to_string()],
"invalidate 后应返回 L3 的新数据"
);
assert_eq!(
interface.perm_count(),
2,
"应查询 L3 两次(首次 + invalidate 后)"
);
}
#[tokio::test]
async fn get_user_l2_hit_backfills_l1_no_repeat_l2_query() {
let (dao, _interface, service) = make_default_service();
dao.insert_direct("user:cache:54001", r#"{"id":54001}"#);
let user1 = service.get_user("54001").await.unwrap();
assert_eq!(user1, Some(r#"{"id":54001}"#.to_string()));
assert_eq!(dao.get_count(), 1, "应查询 L2 一次");
let user2 = service.get_user("54001").await.unwrap();
assert_eq!(user2, Some(r#"{"id":54001}"#.to_string()));
assert_eq!(dao.get_count(), 1, "L1 回填后不应再查询 L2");
let user3 = service.get_user("54001").await.unwrap();
assert_eq!(user3, Some(r#"{"id":54001}"#.to_string()));
assert_eq!(dao.get_count(), 1, "L1 仍命中,不应查询 L2");
}
}