use super::*;
use crate::error::{GarrisonError, GarrisonResult};
use async_trait::async_trait;
use std::collections::HashMap;
use tokio::sync::Mutex;
struct MockDao {
data: Mutex<HashMap<String, String>>,
}
impl MockDao {
fn new() -> Self {
Self {
data: Mutex::new(HashMap::new()),
}
}
}
#[async_trait]
impl GarrisonDao for MockDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
let data = self.data.lock().await;
Ok(data.get(key).cloned())
}
async fn set(&self, key: &str, value: &str, _ttl_seconds: u64) -> GarrisonResult<()> {
let mut data = self.data.lock().await;
data.insert(key.to_string(), value.to_string());
Ok(())
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
let mut data = self.data.lock().await;
if data.contains_key(key) {
data.insert(key.to_string(), value.to_string());
Ok(())
} else {
Err(GarrisonError::Dao(format!("dao-key-not-found::{}", key)))
}
}
async fn expire(&self, _key: &str, _seconds: u64) -> GarrisonResult<()> {
Ok(())
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
let mut data = self.data.lock().await;
data.remove(key);
Ok(())
}
async fn get_and_delete(&self, key: &str) -> GarrisonResult<Option<String>> {
let mut data = self.data.lock().await;
let value = data.get(key).cloned();
if value.is_some() {
data.remove(key);
}
Ok(value)
}
}
fn make_handler() -> TempCredentialHandler {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
TempCredentialHandler::new(dao)
}
#[test]
fn new_creates_handler() {
let _handler = make_handler();
}
#[tokio::test]
async fn issue_returns_key_with_correct_prefix() {
let handler = make_handler();
let key = handler.issue("invite", "payload-data", 600).await.unwrap();
assert!(key.starts_with("garrison:temp:invite:"));
}
#[tokio::test]
async fn issue_multiple_times_returns_different_keys() {
let handler = make_handler();
let k1 = handler.issue("invite", "v1", 60).await.unwrap();
let k2 = handler.issue("invite", "v1", 60).await.unwrap();
assert_ne!(k1, k2);
}
#[tokio::test]
async fn issue_different_prefix_different_namespace() {
let handler = make_handler();
let k1 = handler.issue("invite", "v1", 60).await.unwrap();
let k2 = handler.issue("reset", "v2", 60).await.unwrap();
assert!(k1.starts_with("garrison:temp:invite:"));
assert!(k2.starts_with("garrison:temp:reset:"));
}
#[tokio::test]
async fn issue_zero_ttl_returns_error() {
let handler = make_handler();
let result = handler.issue("invite", "data", 0).await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidParam(_)) => {},
other => panic!("期望 InvalidParam 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn issue_prefix_with_colon_returns_error() {
let handler = make_handler();
let result = handler.issue("inv:ite", "data", 60).await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidParam(_)) => {},
other => panic!("期望 InvalidParam 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn issue_empty_value_allowed() {
let dao = Arc::new(MockDao::new());
let handler = TempCredentialHandler::new(dao.clone());
let key = handler.issue("invite", "", 60).await.unwrap();
let value = dao.get(&key).await.unwrap();
assert_eq!(value, Some("".to_string()));
}
#[tokio::test]
async fn get_returns_value_without_deleting() {
let handler = make_handler();
let key = handler.issue("invite", "data", 60).await.unwrap();
let v1 = handler.get(&key).await.unwrap();
let v2 = handler.get(&key).await.unwrap();
assert_eq!(v1, Some("data".to_string()));
assert_eq!(v2, Some("data".to_string()));
}
#[tokio::test]
async fn get_nonexistent_returns_none() {
let handler = make_handler();
let result = handler
.get("garrison:temp:invite:nonexistent")
.await
.unwrap();
assert_eq!(result, None);
}
#[tokio::test]
async fn revoke_existing_returns_ok() {
let handler = make_handler();
let key = handler.issue("invite", "data", 60).await.unwrap();
let result = handler.revoke(&key).await;
assert!(result.is_ok());
let value = handler.get(&key).await.unwrap();
assert_eq!(value, None);
}
#[tokio::test]
async fn revoke_nonexistent_returns_ok() {
let handler = make_handler();
let result = handler.revoke("garrison:temp:invite:nonexistent").await;
assert!(result.is_ok());
}
#[tokio::test]
async fn consume_returns_value_and_deletes() {
let handler = make_handler();
let key = handler.issue("invite", "data", 60).await.unwrap();
let value = handler.consume(&key).await.unwrap();
assert_eq!(value, Some("data".to_string()));
let again = handler.consume(&key).await.unwrap();
assert_eq!(again, None);
}
#[tokio::test]
async fn consume_twice_returns_none_second_time() {
let handler = make_handler();
let key = handler.issue("invite", "data", 60).await.unwrap();
let v1 = handler.consume(&key).await.unwrap();
let v2 = handler.consume(&key).await.unwrap();
assert_eq!(v1, Some("data".to_string()));
assert_eq!(v2, None);
}
#[tokio::test]
async fn consume_nonexistent_returns_none() {
let handler = make_handler();
let value = handler
.consume("garrison:temp:invite:nonexistent")
.await
.unwrap();
assert_eq!(value, None);
}
#[tokio::test]
async fn consume_after_revoke_returns_none() {
let handler = make_handler();
let key = handler.issue("invite", "data", 60).await.unwrap();
handler.revoke(&key).await.unwrap();
let value = handler.consume(&key).await.unwrap();
assert_eq!(value, None);
}
#[tokio::test(flavor = "multi_thread")]
async fn consume_concurrent_only_one_succeeds() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let handler = Arc::new(TempCredentialHandler::new(dao));
let key = handler
.issue("invite", "concurrent-value", 60)
.await
.unwrap();
let mut handles = Vec::new();
for _ in 0..10 {
let h = handler.clone();
let k = key.clone();
handles.push(tokio::spawn(async move { h.consume(&k).await }));
}
let mut success = 0;
let mut none_count = 0;
for handle in handles {
let result = handle.await.expect("tokio task panicked");
match result {
Ok(Some(_)) => success += 1,
Ok(None) => none_count += 1,
Err(e) => panic!("consume 不应返回错误: {:?}", e),
}
}
assert_eq!(
success, 1,
"并发 consume 仅一个返回 Some(防 double-spend)"
);
assert_eq!(none_count, 9, "其余 9 个返回 None");
}
#[tokio::test]
async fn consume_atomic_still_one_time_use() {
let handler = make_handler();
let key = handler.issue("invite", "data", 60).await.unwrap();
let v1 = handler.consume(&key).await.unwrap();
let v2 = handler.consume(&key).await.unwrap();
let v3 = handler.consume(&key).await.unwrap();
assert_eq!(v1, Some("data".to_string()));
assert_eq!(v2, None);
assert_eq!(v3, None);
}
#[tokio::test]
async fn temp_namespace_isolated() {
let dao = Arc::new(MockDao::new());
dao.set("garrison:temp:invite:abc", "temp-value", 60)
.await
.unwrap();
dao.set("garrison:apikey:abc", "apikey-value", 60)
.await
.unwrap();
let handler = TempCredentialHandler::new(dao.clone());
let value = handler.consume("garrison:temp:invite:abc").await.unwrap();
assert_eq!(value, Some("temp-value".to_string()));
let apikey_value = dao.get("garrison:apikey:abc").await.unwrap();
assert_eq!(apikey_value, Some("apikey-value".to_string()));
}