use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::time::Duration;
use wordval_cache::{Cache, LocalCache, SharedCache};
#[tokio::test]
async fn test_set_and_get() {
let cache = LocalCache::new(100, 0);
cache.set("key1", &"value1".to_string()).await.unwrap();
let val: Option<String> = cache.get("key1").await.unwrap();
assert_eq!(val, Some("value1".to_string()));
}
#[tokio::test]
async fn test_get_missing() {
let cache = LocalCache::new(100, 0);
let val: Option<String> = cache.get("nokey").await.unwrap();
assert_eq!(val, None);
}
#[tokio::test]
async fn test_set_ex_ttl() {
let cache = LocalCache::new(100, 0);
cache.set_ex("temp", &"data", 1).await.unwrap();
let val: Option<String> = cache.get("temp").await.unwrap();
assert_eq!(val, Some("data".to_string()));
tokio::time::sleep(tokio::time::Duration::from_millis(1200)).await;
let val: Option<String> = cache.get("temp").await.unwrap();
assert_eq!(val, None);
}
#[tokio::test]
async fn test_zero_ttl_rejected() {
let cache = LocalCache::new(100, 0);
assert!(cache.set_ex("k1", &"v", 0).await.is_err());
assert!(cache.set_nx("k2", &"v", 0).await.is_err());
assert!(cache.set_raw_ex("k3", b"{}", 0).await.is_err());
assert!(cache.expire("k4", 0).await.is_err());
assert_eq!(cache.sadd("s", &[]).await.unwrap(), 0);
assert_eq!(cache.srem("s", &[]).await.unwrap(), 0);
}
#[tokio::test]
async fn test_delete() {
let cache = LocalCache::new(100, 0);
cache.set("del", &"val").await.unwrap();
cache.del("del").await.unwrap();
let val: Option<String> = cache.get("del").await.unwrap();
assert_eq!(val, None);
}
#[tokio::test]
async fn test_exists() {
let cache = LocalCache::new(100, 0);
cache.set("e1", &"v").await.unwrap();
assert!(cache.exists("e1").await.unwrap());
assert!(!cache.exists("e2").await.unwrap());
}
#[tokio::test]
async fn test_incr() {
let cache = LocalCache::new(100, 0);
let v = cache.incr("counter", 5).await.unwrap();
assert_eq!(v, 5);
let v = cache.incr("counter", 3).await.unwrap();
assert_eq!(v, 8);
}
#[tokio::test]
async fn test_set_nx() {
let cache = LocalCache::new(100, 0);
let ok = cache.set_nx("nx", &"first", 3600).await.unwrap();
assert!(ok);
let ok = cache.set_nx("nx", &"second", 3600).await.unwrap();
assert!(!ok);
let val: Option<String> = cache.get("nx").await.unwrap();
assert_eq!(val, Some("first".to_string()));
}
#[tokio::test]
async fn test_eviction() {
let cache = LocalCache::new(3, 0);
cache.set("a", &"1").await.unwrap();
cache.set("b", &"2").await.unwrap();
cache.set("c", &"3").await.unwrap();
cache.set("d", &"4").await.unwrap(); let count = if cache.exists("a").await.unwrap() {
1
} else {
0
} + if cache.exists("b").await.unwrap() {
1
} else {
0
} + if cache.exists("c").await.unwrap() {
1
} else {
0
} + if cache.exists("d").await.unwrap() {
1
} else {
0
};
assert_eq!(count, 3); }
#[tokio::test]
async fn test_stats() {
let cache = LocalCache::new(100, 0);
cache.set("s1", &"v").await.unwrap();
cache.set("s2", &"v2").await.unwrap();
let _: Option<String> = cache.get("s1").await.unwrap();
let _: Option<String> = cache.get("missing").await.unwrap();
let stats = cache.stats();
assert_eq!(stats.sets, 2);
assert_eq!(stats.hits, 1);
assert_eq!(stats.misses, 1);
}
#[tokio::test]
async fn test_get_expired_does_not_race_with_concurrent_set() {
let cache = LocalCache::new(100, 0);
cache.set_ex("k", &"old", 1).await.unwrap();
tokio::time::sleep(Duration::from_millis(1100)).await;
let c1 = cache.clone();
let h = tokio::spawn(async move {
c1.set("k", &"new").await.unwrap();
});
let _ = cache.get::<String>("k").await.unwrap();
h.await.unwrap();
let val: Option<String> = cache.get("k").await.unwrap();
assert_eq!(
val,
Some("new".to_string()),
"并发写入的新值不应被竞态误删"
);
}
#[tokio::test]
async fn test_sadd_dedup_input_members() {
let cache = LocalCache::new(100, 0);
let added = cache
.sadd("set1", &["a".into(), "a".into(), "b".into()])
.await
.unwrap();
assert_eq!(added, 2);
let members = cache.smembers("set1").await.unwrap();
assert_eq!(members.len(), 2);
assert!(members.contains(&"a".to_string()));
assert!(members.contains(&"b".to_string()));
}
#[tokio::test]
async fn test_sadd_preserves_existing_ttl() {
let cache = LocalCache::new(100, 0);
cache.set_ex("set1", &["x".to_string()], 3600).await.unwrap();
cache.set_ex("set1", &["old".to_string()], 3600).await.unwrap();
cache
.sadd("set1", &["new1".into(), "new2".into()])
.await
.unwrap();
let exists = cache.exists("set1").await.unwrap();
assert!(exists);
}
#[tokio::test]
async fn test_sadd_expired_key_recreates_without_ttl() {
let cache = LocalCache::new(100, 0);
cache.set_ex("set1", &["old".to_string()], 1).await.unwrap();
tokio::time::sleep(Duration::from_millis(1100)).await;
let added = cache.sadd("set1", &["fresh".into()]).await.unwrap();
assert_eq!(added, 1);
let val: Option<Vec<String>> = cache.get("set1").await.unwrap();
assert_eq!(val, Some(vec!["fresh".to_string()]));
}
#[tokio::test]
async fn test_incr_overflow_returns_error() {
let cache = LocalCache::new(100, 0);
cache.set("i", &i64::MAX).await.unwrap();
let err = cache.incr("i", 1).await.unwrap_err();
let msg = format!("{}", err);
assert!(
msg.contains("overflow"),
"incr i64 溢出应返回错误,实际: {}",
msg
);
}
#[tokio::test]
async fn test_incr_non_integer_returns_error() {
let cache = LocalCache::new(100, 0);
cache.set("s", &"not_a_number").await.unwrap();
let err = cache.incr("s", 1).await.unwrap_err();
let msg = format!("{}", err);
assert!(
msg.contains("not an integer"),
"incr 非整数应返回 WRONGTYPE 风格错误,实际: {}",
msg
);
}
#[tokio::test]
async fn test_expire_on_expired_key_returns_false() {
let cache = LocalCache::new(100, 0);
cache.set_ex("e", &"v", 1).await.unwrap();
tokio::time::sleep(Duration::from_millis(1100)).await;
let ok = cache.expire("e", 3600).await.unwrap();
assert!(!ok, "对过期 key 执行 expire 应返回 false(Redis 语义)");
let exists = cache.exists("e").await.unwrap();
assert!(!exists, "过期 key 的 exists 应返回 false");
}
#[tokio::test]
async fn test_exists_cleanup_expired() {
let cache = LocalCache::new(100, 0);
cache.set_ex("e", &"v", 1).await.unwrap();
tokio::time::sleep(Duration::from_millis(1100)).await;
let exists = cache.exists("e").await.unwrap();
assert!(!exists);
let stats = cache.stats();
assert_eq!(stats.misses, 1);
}
#[tokio::test]
async fn test_srem_empty_set_deletes_key() {
let cache = LocalCache::new(100, 0);
cache.sadd("set1", &["a".into(), "b".into()]).await.unwrap();
let removed = cache.srem("set1", &["a".into(), "b".into()]).await.unwrap();
assert_eq!(removed, 2);
let exists = cache.exists("set1").await.unwrap();
assert!(!exists, "集合变空后 key 应被删除(对齐 Redis)");
}
#[tokio::test]
async fn test_set_nx_respects_capacity() {
let cache = LocalCache::new(2, 0);
assert!(cache.set_nx("a", &"1", 3600).await.unwrap());
assert!(cache.set_nx("b", &"2", 3600).await.unwrap());
assert!(cache.set_nx("c", &"3", 3600).await.unwrap());
let total = cache.len();
assert_eq!(total, 2, "容量为 2 时 set_nx 不应突破上限");
}
#[tokio::test]
async fn test_shared_cache_stats_delegation() {
let local = LocalCache::new(100, 0);
local.set("s1", &"v").await.unwrap();
let _: Option<String> = local.get("s1").await.unwrap();
let shared = SharedCache::Local(local);
let stats = shared.stats();
assert_eq!(stats.sets, 1);
assert_eq!(stats.hits, 1);
}
#[tokio::test]
async fn test_raw_bytes_roundtrip() {
let cache = LocalCache::new(100, 0);
let raw = b"{\"hello\":\"world\"}".as_slice();
cache.set_raw("raw1", raw).await.unwrap();
let got = cache.get_raw("raw1").await.unwrap().unwrap();
assert_eq!(got, raw);
}
#[tokio::test]
async fn test_raw_bytes_ex() {
let cache = LocalCache::new(100, 0);
let raw = b"{\"k\":1}".as_slice();
cache.set_raw_ex("raw2", raw, 1).await.unwrap();
tokio::time::sleep(Duration::from_millis(1200)).await;
let got = cache.get_raw("raw2").await.unwrap();
assert_eq!(got, None);
}
#[tokio::test]
async fn test_raw_invalid_json_rejected() {
let cache = LocalCache::new(100, 0);
let err = cache
.set_raw("raw3", b"not json")
.await
.unwrap_err();
assert!(
format!("{}", err).contains("EOF") || format!("{}", err).contains("expected"),
"非法 JSON 应被拒绝"
);
}
#[tokio::test]
async fn test_cleanup_expired_count() {
let cache = LocalCache::new(100, 0);
cache.set_ex("a", &"1", 1).await.unwrap();
cache.set_ex("b", &"2", 1).await.unwrap();
cache.set("c", &"3").await.unwrap();
tokio::time::sleep(Duration::from_millis(1100)).await;
let cleaned = cache.cleanup_expired();
assert_eq!(cleaned, 2);
assert!(!cache.exists("a").await.unwrap());
assert!(!cache.exists("b").await.unwrap());
assert!(cache.exists("c").await.unwrap());
let stats = cache.stats();
assert_eq!(stats.expired_cleanups, 2);
}
#[tokio::test]
async fn test_delete_pattern_count() {
let cache = LocalCache::new(100, 0);
cache.set("pre:a", &"1").await.unwrap();
cache.set("pre:b", &"2").await.unwrap();
cache.set("other", &"3").await.unwrap();
let deleted = cache.delete_pattern("pre:*").await.unwrap();
assert_eq!(deleted, 2);
assert!(!cache.exists("pre:a").await.unwrap());
assert!(!cache.exists("pre:b").await.unwrap());
assert!(cache.exists("other").await.unwrap());
}
#[tokio::test]
async fn test_background_cleanup_exits_when_cache_dropped() {
let cache = LocalCache::new(100, 0).with_cleanup_interval(1);
cache.start_background_cleanup();
cache.set_ex("a", &"1", 1).await.unwrap();
tokio::time::sleep(Duration::from_millis(2300)).await;
assert!(
cache.stats().expired_cleanups >= 1,
"后台任务应在存活期间清理过期条目"
);
drop(cache);
tokio::time::sleep(Duration::from_millis(1500)).await;
}
#[tokio::test]
async fn test_ttl_query() {
let cache = LocalCache::new(100, 0);
assert_eq!(cache.ttl("nokey").await.unwrap(), None);
cache.set("p", &"v").await.unwrap();
assert_eq!(cache.ttl("p").await.unwrap(), None, "无 TTL 的 key 应返回 None");
cache.set_ex("t", &"v", 5).await.unwrap();
let t = cache.ttl("t").await.unwrap();
assert!(
matches!(t, Some(n) if (1..=5).contains(&n)),
"ttl 应为剩余秒数,实际: {:?}",
t
);
cache.set_ex("e", &"v", 1).await.unwrap();
tokio::time::sleep(Duration::from_millis(1100)).await;
assert_eq!(cache.ttl("e").await.unwrap(), None);
}
#[tokio::test]
async fn test_sadd_with_ttl_and_empty_members() {
let cache = LocalCache::new(100, 0);
cache
.sadd_with_ttl("st", &["a".to_string()], 5)
.await
.unwrap();
assert!(
cache.ttl("st").await.unwrap().is_some(),
"sadd_with_ttl 应设置 TTL"
);
cache.sadd_with_ttl("st", &[], 10).await.unwrap();
let members = cache.smembers("st").await.unwrap();
assert_eq!(members, vec!["a".to_string()]);
assert!(cache.ttl("st").await.unwrap().is_some());
assert!(cache.sadd_with_ttl("st2", &["a".to_string()], 0).await.is_err());
}
#[tokio::test]
async fn test_smembers_stats() {
let cache = LocalCache::new(100, 0);
cache.sadd("s1", &["a".to_string()]).await.unwrap();
let _ = cache.smembers("s1").await.unwrap();
let _ = cache.smembers("missing").await.unwrap();
let stats = cache.stats();
assert_eq!(stats.hits, 1, "smembers 命中应计入 hits");
assert_eq!(stats.misses, 1, "smembers 未命中应计入 misses");
}
#[tokio::test]
async fn test_shared_cache_raw_passthrough() {
let cache = SharedCache::Local(LocalCache::new(100, 0));
let raw: &[u8] = br#"{"a": 1}"#;
cache.set_raw("raw1", raw).await.unwrap();
let got = cache.get_raw("raw1").await.unwrap().unwrap();
assert_eq!(got, raw, "SharedCache::Local 的 raw 读写应字节直通,不经 Value 中转");
let raw2: &[u8] = br#"{"b": [1, 2]}"#;
cache.set_raw_ex("raw2", raw2, 100).await.unwrap();
let got2 = cache.get_raw("raw2").await.unwrap().unwrap();
assert_eq!(got2, raw2, "set_raw_ex 同样应字节直通");
assert!(cache.ttl("raw2").await.unwrap().is_some());
}
#[tokio::test]
async fn test_ttl_out_of_range_rejected() {
let cache = LocalCache::new(100, 0);
let huge = (i64::MAX as u64) + 1;
assert!(cache.set_ex("k1", &"v", huge).await.is_err());
assert!(cache.set_nx("k2", &"v", huge).await.is_err());
assert!(cache.set_raw_ex("k3", b"{}", huge).await.is_err());
assert!(cache.expire("k4", huge).await.is_err());
assert!(
cache
.sadd_with_ttl("k5", &["a".to_string()], huge)
.await
.is_err()
);
assert_eq!(cache.len(), 0, "非法 TTL 写入不应留下任何 key");
}
#[tokio::test]
async fn test_set_ignores_default_ttl() {
let cache = LocalCache::new(100, 3600);
cache.set("k", &"v".to_string()).await.unwrap();
assert_eq!(
cache.ttl("k").await.unwrap(),
None,
"set 不应应用 default_ttl"
);
cache.set_raw("raw", b"{}").await.unwrap();
assert_eq!(
cache.ttl("raw").await.unwrap(),
None,
"set_raw 不应应用 default_ttl"
);
let _: String = cache
.get_or_insert_with("sf", 0, || async { Ok("x".to_string()) })
.await
.unwrap();
assert_eq!(
cache.ttl("sf").await.unwrap(),
None,
"get_or_insert_with(ttl=0) 应为永不过期"
);
}
#[tokio::test]
async fn test_create_cache_unknown_type_rejected() {
let cache_cfg = wordval_config::CacheConfig {
r#type: "loacl".into(),
max_capacity: 100,
default_ttl: 3600,
};
let redis_cfg = wordval_config::RedisConfig {
enabled: false,
url: "redis://127.0.0.1:6379".into(),
max_connections: 10,
};
let err = match wordval_cache::create_cache(&cache_cfg, &redis_cfg).await {
Ok(_) => panic!("未知 cache.type 应返回配置错误"),
Err(e) => e,
};
let msg = format!("{err}");
assert!(
msg.contains("loacl") && msg.contains("cache.type"),
"错误信息应包含无效 type 原值,实际: {msg}"
);
}
#[tokio::test]
async fn test_get_or_insert_with_basic() {
let cache = LocalCache::new(100, 0);
let v: i64 = cache
.get_or_insert_with("sf1", 60, || async { Ok(42) })
.await
.unwrap();
assert_eq!(v, 42);
let loaded = Arc::new(AtomicUsize::new(0));
let l2 = loaded.clone();
let v2: i64 = cache
.get_or_insert_with("sf1", 60, move || {
let loaded = l2.clone();
async move {
loaded.fetch_add(1, Ordering::Relaxed);
Ok(42)
}
})
.await
.unwrap();
assert_eq!(v2, 42);
assert_eq!(loaded.load(Ordering::Relaxed), 0, "命中后不应再回源");
assert!(cache.ttl("sf1").await.unwrap().is_some(), "ttl>0 应写入 TTL");
}
#[tokio::test]
async fn test_get_or_insert_with_ttl_zero_permanent() {
let cache = LocalCache::new(100, 0);
let _: i64 = cache
.get_or_insert_with("sf2", 0, || async { Ok(7) })
.await
.unwrap();
assert_eq!(cache.ttl("sf2").await.unwrap(), None, "ttl=0 应为永不过期");
}
#[tokio::test]
async fn test_get_or_insert_with_single_flight() {
let cache = LocalCache::new(100, 0);
let loaded = Arc::new(AtomicUsize::new(0));
let mut handles = Vec::new();
for _ in 0..32 {
let cache = cache.clone();
let loaded = loaded.clone();
handles.push(tokio::spawn(async move {
cache
.get_or_insert_with("sf3", 60, move || {
let loaded = loaded.clone();
async move {
tokio::time::sleep(Duration::from_millis(50)).await;
loaded.fetch_add(1, Ordering::Relaxed);
Ok("v".to_string())
}
})
.await
.unwrap()
}));
}
for h in handles {
h.await.unwrap();
}
assert_eq!(
loaded.load(Ordering::Relaxed),
1,
"同 key 32 路并发应只回源一次"
);
}
#[tokio::test]
async fn test_get_or_insert_with_error_not_cached() {
let cache = LocalCache::new(100, 0);
let first = cache
.get_or_insert_with::<String, _, _>("sf4", 60, || async {
Err(wordval_cache::Error::Msg("boom".into()))
})
.await;
assert!(first.is_err(), "加载失败应向上传播");
assert!(!cache.exists("sf4").await.unwrap(), "失败结果不应写入缓存");
let loaded = Arc::new(AtomicUsize::new(0));
let l2 = loaded.clone();
let v: String = cache
.get_or_insert_with("sf4", 60, move || {
let loaded = l2.clone();
async move {
loaded.fetch_add(1, Ordering::Relaxed);
Ok("ok".to_string())
}
})
.await
.unwrap();
assert_eq!(v, "ok");
assert_eq!(loaded.load(Ordering::Relaxed), 1);
}