use crate::cache::dao_backend::GarrisonDaoCacheBackend;
use crate::constants::DaoKeyPrefix;
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use crate::strategy::GarrisonPermissionStrategy;
use oxcache::backend::{CacheWriter, DashMapMemoryBackend};
use oxcache::cache::ChainCache;
use oxcache::Cache;
use std::sync::Arc;
use std::time::Duration;
pub struct UserCacheService {
list_cache: Cache<String, Vec<String>>,
user_cache: Cache<String, String>,
l1: DashMapMemoryBackend,
dao: Arc<dyn GarrisonDao>,
interface: Arc<dyn GarrisonPermissionStrategy>,
l1_ttl_secs: u64,
l2_ttl_secs: u64,
#[cfg(feature = "cache-hotkey")]
hot_keys: oxcache::features::HotKeyTracker,
}
impl UserCacheService {
pub fn new(
dao: Arc<dyn GarrisonDao>,
interface: Arc<dyn GarrisonPermissionStrategy>,
l1_ttl_secs: u64,
l2_ttl_secs: u64,
) -> GarrisonResult<Self> {
Self::new_with_capacity(
dao,
interface,
l1_ttl_secs,
l2_ttl_secs,
crate::config::DEFAULT_L1_CACHE_CAPACITY,
)
}
pub fn new_with_capacity(
dao: Arc<dyn GarrisonDao>,
interface: Arc<dyn GarrisonPermissionStrategy>,
l1_ttl_secs: u64,
l2_ttl_secs: u64,
l1_capacity: u64,
) -> GarrisonResult<Self> {
if l1_ttl_secs == 0 {
return Err(GarrisonError::Config(
"cache-l1-ttl-must-positive".to_string(),
));
}
if l2_ttl_secs == 0 {
return Err(GarrisonError::Config(
"cache-l2-ttl-must-positive".to_string(),
));
}
if l1_capacity == 0 {
return Err(GarrisonError::Config(
"cache-l1-capacity-must-positive".to_string(),
));
}
let l1 = DashMapMemoryBackend::builder()
.capacity(l1_capacity as usize)
.default_ttl(Duration::from_secs(l1_ttl_secs))
.build();
let l2 = GarrisonDaoCacheBackend::new(
dao.clone(),
GarrisonDaoCacheBackend::cache_clear_prefixes(),
);
let chain: Arc<dyn oxcache::backend::CacheBackend> = Arc::new(
ChainCache::builder()
.backend(l1.clone())
.backend(l2)
.enable_backfill()
.build(),
);
let list_cache = Cache::<String, Vec<String>>::builder()
.backend_arc(Arc::clone(&chain))
.build_sync()
.map_err(|e| GarrisonError::Internal(format!("cache-l1-init::{}", e)))?;
let user_cache = Cache::<String, String>::builder()
.backend_arc(chain)
.build_sync()
.map_err(|e| GarrisonError::Internal(format!("cache-l1-init::{}", e)))?;
Ok(Self {
list_cache,
user_cache,
l1,
dao,
interface,
l1_ttl_secs,
l2_ttl_secs,
#[cfg(feature = "cache-hotkey")]
hot_keys: oxcache::features::HotKeyTracker::new(64),
})
}
#[cfg(not(feature = "cache-hotkey"))]
fn record_hot_key(&self, _key: &str) {}
#[cfg(feature = "cache-hotkey")]
fn record_hot_key(&self, key: &str) {
self.hot_keys.record(key);
}
#[cfg(feature = "cache-hotkey")]
pub fn hot_keys_top(&self, k: usize) -> Vec<(String, u64)> {
self.hot_keys.snapshot_top(k)
}
pub fn l1_ttl_secs(&self) -> u64 {
self.l1_ttl_secs
}
pub fn l2_ttl_secs(&self) -> u64 {
self.l2_ttl_secs
}
async fn load_list_with<F, Fut>(&self, key: &str, fallback: F) -> GarrisonResult<Vec<String>>
where
F: FnOnce() -> Fut,
Fut: std::future::Future<Output = GarrisonResult<Vec<String>>>,
{
let mut l3_err: Option<GarrisonError> = None;
let mut l3_value: Option<Vec<String>> = None;
let mut fallback = Some(fallback);
let key_owned = key.to_string();
let result = self
.list_cache
.get_or(&key_owned, || async {
let fb = fallback.take().unwrap_or_else(|| {
panic!(
"{}",
crate::i18n::translate_detail("cache-fallback-consumed-once", &[],)
)
});
match fb().await {
Ok(v) => {
l3_value = Some(v.clone());
Ok(v)
},
Err(e) => {
l3_err = Some(e);
Err(oxcache::error::OxCacheError::BackendError(
"garrison-cache-l3-fallback".to_string(),
))
},
}
})
.await;
match result {
Ok(v) => Ok(v),
Err(e) => {
if let Some(l3e) = l3_err {
return Err(l3e);
}
if let Some(v) = l3_value {
tracing::warn!(
key = %key_owned,
error = %e,
"{}", crate::i18n::translate_detail("logs-cache-l3-write-back-failed", &[])
);
return Ok(v);
}
tracing::warn!(
key = %key_owned,
error = %e,
"{}", crate::i18n::translate_detail("logs-cache-chain-read-failed-evict-and-fallback", &[])
);
let _ = self.list_cache.delete(&key_owned).await;
fallback.unwrap_or_else(|| {
panic!(
"{}",
crate::i18n::translate_detail("cache-fallback-not-yet-executed", &[],)
)
})()
.await
},
}
}
async fn load_user_with<F, Fut>(&self, key: &str, fallback: F) -> GarrisonResult<Option<String>>
where
F: FnOnce() -> Fut,
Fut: std::future::Future<Output = GarrisonResult<Option<String>>>,
{
let mut l3_err: Option<GarrisonError> = None;
let mut l3_value: Option<Option<String>> = None;
let mut fallback = Some(fallback);
let key_owned = key.to_string();
let result = self
.user_cache
.get_or_option(&key_owned, || async {
let fb = fallback.take().unwrap_or_else(|| {
panic!(
"{}",
crate::i18n::translate_detail("cache-fallback-consumed-once", &[],)
)
});
match fb().await {
Ok(v) => {
l3_value = Some(v.clone());
Ok(v)
},
Err(e) => {
l3_err = Some(e);
Err(oxcache::error::OxCacheError::BackendError(
"garrison-cache-l3-fallback".to_string(),
))
},
}
})
.await;
match result {
Ok(v) => Ok(v),
Err(e) => {
if let Some(l3e) = l3_err {
return Err(l3e);
}
if let Some(v) = l3_value {
tracing::warn!(
key = %key_owned,
error = %e,
"{}", crate::i18n::translate_detail("logs-cache-l3-write-back-failed", &[])
);
return Ok(v);
}
tracing::warn!(
key = %key_owned,
error = %e,
"{}", crate::i18n::translate_detail("logs-cache-chain-read-failed-evict-and-fallback", &[])
);
let _ = self.user_cache.delete(&key_owned).await;
fallback.unwrap_or_else(|| {
panic!(
"{}",
crate::i18n::translate_detail("cache-fallback-not-yet-executed", &[],)
)
})()
.await
},
}
}
pub async fn get_permissions(&self, login_id: &str) -> GarrisonResult<Vec<String>> {
let key = DaoKeyPrefix::PermissionCache.build_key(login_id);
self.record_hot_key(&key);
self.load_list_with(&key, || async {
self.interface.get_permission_list(login_id).await
})
.await
}
pub async fn get_roles(&self, login_id: &str) -> GarrisonResult<Vec<String>> {
let key = DaoKeyPrefix::RoleCache.build_key(login_id);
self.record_hot_key(&key);
self.load_list_with(&key, || async {
self.interface.get_role_list(login_id).await
})
.await
}
pub async fn get_user(&self, login_id: &str) -> GarrisonResult<Option<String>> {
let key = DaoKeyPrefix::UserCache.build_key(login_id);
self.record_hot_key(&key);
self.load_user_with(&key, || async {
self.interface.get_user_info(login_id).await
})
.await
}
pub async fn invalidate(&self, login_id: &str) -> GarrisonResult<()> {
let keys = [
DaoKeyPrefix::PermissionCache.build_key(login_id),
DaoKeyPrefix::RoleCache.build_key(login_id),
DaoKeyPrefix::UserCache.build_key(login_id),
];
let mut first_err: Option<GarrisonError> = None;
let mut deleted = 0usize;
for key in &keys {
let l2_result = self.dao.delete(key).await;
let l1_result = self
.l1
.delete(key)
.await
.map_err(|e| GarrisonError::Internal(format!("cache-l1-delete::{}", e)));
for result in [l2_result, l1_result] {
match result {
Ok(()) => deleted += 1,
Err(e) => {
if first_err.is_none() {
first_err = Some(e);
}
},
}
}
}
if let Some(e) = first_err {
tracing::warn!(
login_id = %login_id,
deleted,
total = keys.len() * 2,
error = %e,
"cache invalidate completed with errors; all deletes were attempted, retry is idempotent"
);
return Err(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(())
}
crate::atomic_test_fallback!();
}
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))
}
async fn check_permission_in_tenant(
&self,
_tenant_id: i64,
_login_id: &str,
_permission: &str,
) -> GarrisonResult<bool> {
Ok(false)
}
async fn check_role_in_tenant(
&self,
_tenant_id: i64,
_login_id: &str,
_role: &str,
) -> GarrisonResult<bool> {
Ok(false)
}
#[cfg(any(
feature = "sms-rate-limit",
feature = "firewall-ratelimit",
feature = "firewall-bruteforce",
feature = "firewall-ddos",
feature = "firewall",
feature = "oauth2-server"
))]
async fn check_login_hooks(
&self,
_login_id: &str,
_ctx: &crate::strategy::hooks::LoginContext,
) -> GarrisonResult<()> {
Ok(())
}
}
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,
)
.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(),
2,
"第一次应查询 L2(get_or 快路径 + leader 复查)"
);
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(), 2, "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 命中路径:链读一次(无 fallback)");
let perms2 = service.get_permissions("2001").await.unwrap();
assert_eq!(perms2, vec!["admin:read".to_string()]);
assert_eq!(
dao.get_count(),
1,
"L1 回填后不应再查询 L2(命中路径总量保持 1)"
);
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(),
2,
"应查询 L2 一次(get_or 快路径 + leader 复查,miss 路径双读)"
);
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,
)
.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(),
4,
"应查询 L2 两次(get_or 每轮 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,
)
.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,
)
.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,
)
.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,
)
.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(),
2,
"第一次应查询 L2(get_or 快路径 + leader 复查)"
);
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(), 2, "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 命中路径:链读一次(无 fallback)");
let roles2 = service.get_roles("18001").await.unwrap();
assert_eq!(roles2, vec!["editor".to_string()]);
assert_eq!(
dao.get_count(),
1,
"L1 回填后不应再查询 L2(命中路径总量保持 1)"
);
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(),
2,
"第一次应查询 L2(get_or 快路径 + leader 复查)"
);
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(), 2, "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 命中路径:链读一次(无 fallback)");
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(命中路径总量保持 1)"
);
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(),
2,
"应查询 L2 一次(get_or 快路径 + leader 复查,miss 路径双读)"
);
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();
interface.set_permissions("22001", vec!["perm:ok".to_string()]);
dao.insert_direct("perm:cache:22001", "{invalid json");
let result = service.get_permissions("22001").await;
assert_eq!(
result.unwrap(),
vec!["perm:ok".to_string()],
"L2 损坏值应逐出后回源 L3 并返回 L3 数据"
);
}
#[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_falls_back_to_l3() {
let (dao, interface, service) = make_default_service();
interface.set_permissions("24001", vec!["perm:ok".to_string()]);
dao.set_fail_get(true);
let result = service.get_permissions("24001").await;
assert_eq!(
result.unwrap(),
vec!["perm:ok".to_string()],
"L2 DAO get 失败应降级 L3 返回 L3 数据"
);
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_eq!(
result.unwrap(),
vec!["perm:set_fail".to_string()],
"L2 DAO set 失败应返回 L3 数据(不缓存)"
);
}
#[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()
);
}
#[tokio::test]
async fn invalidate_attempts_all_deletes_on_partial_failure() {
let (dao, _interface, service) = make_default_service();
dao.set_fail_delete(true);
let result = service.invalidate("26001").await;
assert!(result.is_err(), "存在失败 delete 应返回 Err");
assert_eq!(
dao.delete_count(),
3,
"即使失败也应尝试全部 3 次 L2 delete,实际: {}",
dao.delete_count()
);
match result {
Err(GarrisonError::Dao(msg)) => {
assert!(msg.contains("injected delete error"), "实际: {}", msg);
},
Err(other) => panic!("期望 GarrisonError::Dao,实际: {:?}", other),
Ok(_) => panic!("期望 Err,实际 Ok"),
}
}
#[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();
interface.set_permissions("27001", vec!["user:read".to_string()]);
let key = "perm:cache:27001".to_string();
dao.insert_direct(&key, "{invalid json");
let result = service.get_permissions("27001").await;
assert_eq!(
result.unwrap(),
vec!["user:read".to_string()],
"损坏缓存应逐出后回源 L3 并返回 L3 数据"
);
let again = service.get_permissions("27001").await.unwrap();
assert_eq!(again, vec!["user:read".to_string()]);
assert!(
dao.contains_key("perm:cache:27001"),
"自愈路径应重新回填 L2"
);
}
#[tokio::test]
async fn l1_corrupt_role_cache_returns_internal_error() {
let (dao, interface, service) = make_default_service();
interface.set_roles("28001", vec!["role:admin".to_string()]);
let key = "role:cache:28001".to_string();
dao.insert_direct(&key, "{invalid json");
let result = service.get_roles("28001").await;
assert_eq!(
result.unwrap(),
vec!["role:admin".to_string()],
"损坏缓存应逐出后回源 L3 并返回 L3 数据"
);
let again = service.get_roles("28001").await.unwrap();
assert_eq!(again, vec!["role:admin".to_string()]);
assert!(
dao.contains_key("role:cache:28001"),
"自愈路径应重新回填 L2"
);
}
#[tokio::test]
async fn l2_corrupt_role_cache_returns_internal_error() {
let (dao, interface, service) = make_default_service();
interface.set_roles("29001", vec!["role:ok".to_string()]);
dao.insert_direct("role:cache:29001", "{invalid json");
let result = service.get_roles("29001").await;
assert_eq!(
result.unwrap(),
vec!["role:ok".to_string()],
"L2 损坏值应逐出后回源 L3 并返回 L3 数据"
);
}
#[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(),
2,
"应查询 L2 一次(get_or 快路径 + leader 复查,miss 路径双读)"
);
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();
interface.set_roles("37001", vec!["role:ok".to_string()]);
dao.set_fail_get(true);
let result = service.get_roles("37001").await;
assert_eq!(
result.unwrap(),
vec!["role:ok".to_string()],
"L2 DAO get 失败应回源 L3 返回角色数据"
);
}
#[tokio::test]
async fn l2_dao_get_failure_propagates_error_for_get_user() {
let (dao, interface, service) = make_default_service();
interface.set_user_info("38001", Some(r#"{"id":38001}"#.to_string()));
dao.set_fail_get(true);
let result = service.get_user("38001").await;
assert_eq!(
result.unwrap(),
Some(r#"{"id":38001}"#.to_string()),
"L2 DAO get 失败应回源 L3 返回用户信息"
);
}
#[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_eq!(
result.unwrap(),
vec!["editor".to_string()],
"L2 DAO set 失败应返回 L3 数据(不缓存)"
);
}
#[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_eq!(
result.unwrap(),
Some(r#"{"id":40001}"#.to_string()),
"L2 DAO set 失败应返回 L3 数据(不缓存)"
);
}
#[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(),
3,
"失败后应继续尝试全部 L2 delete(聚合错误语义),实际执行: 3"
);
}
#[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_deserialized_string() {
let (dao, _interface, service) = make_default_service();
dao.insert_direct("user:cache:45001", r#""{\"name\":\"bob\"}""#);
let user = service.get_user("45001").await.unwrap();
assert_eq!(
user,
Some(r#"{"name":"bob"}"#.to_string()),
"get_user 应返回 L2 值反序列化后的字符串"
);
}
#[tokio::test]
async fn get_user_legacy_raw_l2_value_tolerated_via_l3() {
let (dao, interface, service) = make_default_service();
interface.set_user_info("45002", Some(r#"{"id":45002}"#.to_string()));
dao.insert_direct("user:cache:45002", "legacy-raw-value");
let user = service.get_user("45002").await.unwrap();
assert_eq!(
user,
Some(r#"{"id":45002}"#.to_string()),
"旧格式残留应逐出后回源 L3,返回 L3 数据"
);
}
#[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 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,
)
.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 命中路径:链读一次(无 fallback)");
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(命中路径总量保持 1)"
);
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(命中路径总量保持 1)"
);
}
#[tokio::test]
async fn counting_mock_dao_atomic_and_default_methods_coverage() {
use crate::dao::GarrisonDao;
let dao = CountingMockDao::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_with_ttl("k1").await;
let _ = dao.get_timeout("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;
}
}
fn build_with_capacity(l1: u64, l2: u64, cap: u64) -> GarrisonResult<UserCacheService> {
let dao = Arc::new(CountingMockDao::new());
let iface = Arc::new(CountingMockInterface::new());
UserCacheService::new_with_capacity(
dao as Arc<dyn GarrisonDao>,
iface as Arc<dyn GarrisonPermissionStrategy>,
l1,
l2,
cap,
)
}
#[test]
fn rejects_zero_l1_ttl() {
let err = match build_with_capacity(0, 300, 128) {
Err(e) => e,
Ok(_) => panic!("l1_ttl=0 应被拒绝"),
};
assert!(
matches!(&err, GarrisonError::Config(m) if m.contains("cache-l1-ttl-must-positive")),
"l1_ttl=0 应报 cache-l1-ttl-must-positive,实际: {err:?}"
);
}
#[test]
fn rejects_zero_l2_ttl() {
let err = match build_with_capacity(30, 0, 128) {
Err(e) => e,
Ok(_) => panic!("l2_ttl=0 应被拒绝"),
};
assert!(
matches!(&err, GarrisonError::Config(m) if m.contains("cache-l2-ttl-must-positive")),
"l2_ttl=0 应报 cache-l2-ttl-must-positive,实际: {err:?}"
);
}
#[test]
fn rejects_zero_l1_capacity() {
let err = match build_with_capacity(30, 300, 0) {
Err(e) => e,
Ok(_) => panic!("capacity=0 应被拒绝"),
};
assert!(
matches!(&err, GarrisonError::Config(m) if m.contains("cache-l1-capacity-must-positive")),
"capacity=0 应报 cache-l1-capacity-must-positive,实际: {err:?}"
);
}
#[test]
fn accepts_positive_params() {
assert!(build_with_capacity(30, 300, 128).is_ok());
}
#[cfg(feature = "cache-hotkey")]
#[tokio::test]
async fn hot_keys_top_records_l1_accesses() {
let (_dao, _interface, service) = make_service(300, 600);
let _ = service.get_permissions("u1").await.unwrap();
let _ = service.get_permissions("u1").await.unwrap();
let key = DaoKeyPrefix::PermissionCache.build_key("u1");
let top = service.hot_keys_top(10);
let (_, count) = top
.iter()
.find(|(k, _)| k == &key)
.unwrap_or_else(|| panic!("权限缓存键应被记录,实际 top: {top:?}"));
assert!(*count >= 2, "两次访问计数应 ≥2,实际 {count}");
}
#[cfg(feature = "cache-hotkey")]
#[tokio::test]
async fn hot_keys_top_empty_returns_empty() {
let (_dao, _interface, service) = make_service(300, 600);
assert!(service.hot_keys_top(10).is_empty());
}
#[cfg(feature = "cache-hotkey")]
#[tokio::test]
async fn hot_keys_top_respects_k_limit() {
let (_dao, _interface, service) = make_service(300, 600);
let _ = service.get_permissions("u1").await.unwrap();
let _ = service.get_roles("u1").await.unwrap();
let _ = service.get_user("u1").await.unwrap();
let top = service.hot_keys_top(2);
assert_eq!(top.len(), 2, "k=2 应截断为 2 条,实际: {top:?}");
}
}