use super::mock::MockDao;
use super::*;
use crate::error::GarrisonError;
use std::time::{SystemTime, UNIX_EPOCH};
fn make_handler() -> ApiKeyHandler {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
ApiKeyHandler::new(dao)
}
#[test]
fn new_creates_handler() {
let _handler = make_handler();
}
#[tokio::test]
async fn generate_returns_64_chars() {
let handler = make_handler();
let key = handler
.generate("1001", vec!["read".into()], 3600)
.await
.unwrap();
assert_eq!(key.len(), 64);
assert!(key.chars().all(|c| c.is_ascii_hexdigit()));
}
#[tokio::test]
async fn generate_multiple_times_returns_different_keys() {
let handler = make_handler();
let k1 = handler.generate("1001", vec![], 3600).await.unwrap();
let k2 = handler.generate("1001", vec![], 3600).await.unwrap();
assert_ne!(k1, k2);
}
#[tokio::test]
async fn generate_zero_timeout_returns_error() {
let handler = make_handler();
let result = handler.generate("1001", vec![], 0).await;
assert!(result.is_err());
}
#[tokio::test]
async fn generate_uses_correct_key_prefix() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let key = handler
.generate("1001", vec!["read".into()], 3600)
.await
.unwrap();
let dao_key = format!("garrison:apikey:default:{}", key);
let value = dao.get(&dao_key).await.unwrap();
assert!(value.is_some());
let info: ApiKeyInfo = serde_json::from_str(&value.unwrap()).unwrap();
assert_eq!(info.login_id, "1001");
assert_eq!(info.scopes, vec!["read".to_string()]);
assert!(!info.revoked);
assert_eq!(info.namespace, "default");
}
#[tokio::test]
async fn verify_success_returns_info() {
let handler = make_handler();
let key = handler
.generate("1001", vec!["read".into(), "write".into()], 3600)
.await
.unwrap();
let info = handler.verify(&key).await.unwrap();
assert_eq!(info.login_id, "1001");
assert_eq!(info.scopes, vec!["read".to_string(), "write".to_string()]);
assert!(!info.revoked);
}
#[tokio::test]
async fn verify_nonexistent_returns_error() {
let handler = make_handler();
let result = handler.verify("nonexistent-key").await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidToken(_)) => {},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn verify_revoked_returns_error() {
let handler = make_handler();
let key = handler.generate("1001", vec![], 3600).await.unwrap();
handler.revoke(&key).await.unwrap();
let result = handler.verify(&key).await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidToken(_)) => {},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn verify_expired_returns_error() {
let handler = make_handler();
let key = handler.generate("1001", vec![], 1).await.unwrap();
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
let result = handler.verify(&key).await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::ExpiredToken(_)) => {},
other => panic!("期望 ExpiredToken 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn revoke_success() {
let handler = make_handler();
let key = handler.generate("1001", vec![], 3600).await.unwrap();
let result = handler.revoke(&key).await;
assert!(result.is_ok());
let verify_result = handler.verify(&key).await;
assert!(verify_result.is_err());
}
#[tokio::test]
async fn revoke_nonexistent_returns_error() {
let handler = make_handler();
let result = handler.revoke("nonexistent-key").await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidToken(_)) => {},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn rotate_success() {
let handler = make_handler();
let old_key = handler
.generate("1001", vec!["read".into()], 3600)
.await
.unwrap();
let new_key = handler.rotate(&old_key).await.unwrap();
assert_ne!(old_key, new_key);
assert_eq!(new_key.len(), 64);
let old_result = handler.verify(&old_key).await;
assert!(old_result.is_err());
let info = handler.verify(&new_key).await.unwrap();
assert_eq!(info.login_id, "1001");
assert_eq!(info.scopes, vec!["read".to_string()]);
}
#[tokio::test]
async fn rotate_nonexistent_returns_error() {
let handler = make_handler();
let result = handler.rotate("nonexistent-key").await;
assert!(result.is_err());
}
#[tokio::test]
async fn mock_dao_expire_and_delete_covered() {
let dao = MockDao::new();
dao.set("k", "v", 3600).await.unwrap();
dao.expire("k", 7200).await.unwrap();
let got = dao.get("k").await.unwrap();
assert_eq!(got, Some("v".to_string()));
dao.delete("k").await.unwrap();
let got = dao.get("k").await.unwrap();
assert!(got.is_none());
}
#[tokio::test]
async fn generate_negative_timeout_returns_error() {
let handler = make_handler();
let result = handler.generate("1001", vec![], -1).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
GarrisonError::InvalidParam(_)
));
}
#[tokio::test]
async fn rotate_revoked_key_returns_error() {
let handler = make_handler();
let key = handler
.generate("1001", vec!["read".into()], 3600)
.await
.unwrap();
handler.revoke(&key).await.unwrap();
let result = handler.rotate(&key).await;
assert!(result.is_err());
}
#[tokio::test]
async fn generate_accepts_login_id_numeric() {
let handler = make_handler();
let key = handler
.generate("1001".to_string(), vec!["read".into()], 3600)
.await
.unwrap();
let info = handler.verify(&key).await.unwrap();
assert_eq!(info.login_id, "1001");
}
#[test]
fn apikey_info_serializes_with_namespace() {
let info = ApiKeyInfo {
login_id: "1".to_string(),
scopes: vec![],
expire_at: 0,
revoked: false,
namespace: "internal".to_string(),
};
let json = serde_json::to_string(&info).unwrap();
assert!(json.contains("\"namespace\""), "JSON 应包含 namespace 字段");
assert!(json.contains("\"internal\""), "namespace 值应为 internal");
}
#[test]
fn apikey_info_old_json_deserializes_with_default_namespace() {
let old_json = r#"{"login_id":"1","scopes":[],"expire_at":0,"revoked":false}"#;
let info: ApiKeyInfo = serde_json::from_str(old_json).unwrap();
assert_eq!(
info.namespace, "default",
"旧 JSON 应反序列化为 namespace=default"
);
assert_eq!(info.login_id, "1");
}
#[tokio::test]
#[serial_test::serial]
async fn generate_with_namespace_stores_new_format_key() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let key = handler
.generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
.await
.unwrap();
let dao_key = format!("garrison:apikey:internal:{}", key);
let value = dao.get(&dao_key).await.unwrap();
assert!(value.is_some(), "新格式 key 应存在: {}", dao_key);
let info: ApiKeyInfo = serde_json::from_str(&value.unwrap()).unwrap();
assert_eq!(info.namespace, "internal");
assert_eq!(info.login_id, "1001");
let old_key = format!("garrison:apikey:{}", key);
let old_value = dao.get(&old_key).await.unwrap();
assert!(old_value.is_none(), "旧格式 key 不应存在");
}
#[tokio::test]
#[serial_test::serial]
async fn verify_compatible_with_old_key_format() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let old_key = "deadbeef".repeat(8); let old_dao_key = format!("garrison:apikey:{}", old_key);
let info = ApiKeyInfo {
login_id: "2002".to_string(),
scopes: vec!["legacy".into()],
expire_at: SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs() as i64
+ 3600,
revoked: false,
namespace: "default".to_string(),
};
let value = serde_json::to_string(&info).unwrap();
dao.set(&old_dao_key, &value, 3600).await.unwrap();
let verified = handler.verify(&old_key).await.unwrap();
assert_eq!(verified.login_id, "2002");
assert_eq!(verified.scopes, vec!["legacy".to_string()]);
}
#[tokio::test]
#[serial_test::serial]
async fn list_by_namespace_returns_only_matching_namespace() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let _k1 = handler
.generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
.await
.unwrap();
let _k2 = handler
.generate_with_namespace("2002", "partner", vec!["write".into()], 3600)
.await
.unwrap();
let internal_keys = handler.list_by_namespace("internal").await.unwrap();
assert_eq!(internal_keys.len(), 1, "internal namespace 应有 1 个 key");
assert_eq!(internal_keys[0].login_id, "1001");
assert_eq!(internal_keys[0].namespace, "internal");
let partner_keys = handler.list_by_namespace("partner").await.unwrap();
assert_eq!(partner_keys.len(), 1, "partner namespace 应有 1 个 key");
assert_eq!(partner_keys[0].login_id, "2002");
let empty = handler.list_by_namespace("nonexistent").await.unwrap();
assert!(empty.is_empty(), "不存在的 namespace 应返回空 Vec");
}
#[tokio::test]
#[serial_test::serial]
async fn list_by_namespace_filters_revoked_keys() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let k1 = handler
.generate_with_namespace("1001", "internal", vec![], 3600)
.await
.unwrap();
let _k2 = handler
.generate_with_namespace("1002", "internal", vec![], 3600)
.await
.unwrap();
handler.revoke(&k1).await.unwrap();
let keys = handler.list_by_namespace("internal").await.unwrap();
assert_eq!(keys.len(), 1, "吊销后应只剩 1 个未吊销 key");
assert_eq!(keys[0].login_id, "1002");
}
#[tokio::test]
#[serial_test::serial]
async fn verify_with_namespace_enforces_isolation() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let key = handler
.generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
.await
.unwrap();
let info = handler
.verify_with_namespace(&key, "internal")
.await
.unwrap();
assert_eq!(info.login_id, "1001");
assert_eq!(info.namespace, "internal");
let wrong = handler.verify_with_namespace(&key, "partner").await;
assert!(
matches!(wrong, Err(GarrisonError::InvalidToken(_))),
"跨 namespace 校验应返回 InvalidToken,实际: {:?}",
wrong
);
}
#[tokio::test]
#[serial_test::serial]
async fn verify_without_namespace_scans_all_namespaces() {
let handler = make_handler();
let key = handler
.generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
.await
.unwrap();
let info = handler.verify(&key).await.unwrap();
assert_eq!(info.login_id, "1001");
assert_eq!(info.namespace, "internal");
}
#[tokio::test]
async fn generate_with_namespace_validates_namespace() {
let handler = make_handler();
let r = handler.generate_with_namespace("1", "", vec![], 3600).await;
assert!(
matches!(r, Err(GarrisonError::InvalidParam(_))),
"空 namespace 应报错"
);
let long_ns = "a".repeat(65);
let r = handler
.generate_with_namespace("1", &long_ns, vec![], 3600)
.await;
assert!(
matches!(r, Err(GarrisonError::InvalidParam(_))),
"65 字符 namespace 应报错"
);
let r = handler
.generate_with_namespace("1", "has space", vec![], 3600)
.await;
assert!(
matches!(r, Err(GarrisonError::InvalidParam(_))),
"含空格 namespace 应报错"
);
let r = handler
.generate_with_namespace("1", &"a".repeat(64), vec![], 3600)
.await;
assert!(r.is_ok(), "64 字符 namespace 应通过");
let r = handler
.generate_with_namespace("1", "ns_name-1", vec![], 3600)
.await;
assert!(r.is_ok(), "含 _ - 数字 的 namespace 应通过");
}
#[tokio::test]
#[serial_test::serial]
async fn verify_with_namespace_returns_error_when_namespace_mismatch() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let key = "deadbeef".repeat(8); let dao_key = format!("garrison:apikey:internal:{}", key);
let info = ApiKeyInfo {
login_id: "1001".to_string(),
scopes: vec![],
expire_at: SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs() as i64
+ 3600,
revoked: false,
namespace: "other".to_string(),
};
let value = serde_json::to_string(&info).unwrap();
dao.set(&dao_key, &value, 3600).await.unwrap();
let result = handler.verify_with_namespace(&key, "internal").await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(ref msg)) if msg.starts_with("apikey-namespace-mismatch::")),
"namespace 不匹配应返回 InvalidToken,实际: {:?}",
result
);
}
#[tokio::test]
async fn verify_returns_internal_error_when_json_invalid() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let key = "deadbeef".repeat(8);
let dao_key = format!("garrison:apikey:{}", key);
dao.set(&dao_key, "invalid-json", 3600).await.unwrap();
let result = handler.verify(&key).await;
assert!(
matches!(result, Err(GarrisonError::Internal(ref msg)) if msg.contains("apikey-deserialize")),
"无效 JSON 应返回 Internal 错误,实际: {:?}",
result
);
}
#[tokio::test]
async fn revoke_returns_internal_error_when_json_invalid() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let key = "deadbeef".repeat(8);
let dao_key = format!("garrison:apikey:{}", key);
dao.set(&dao_key, "invalid-json", 3600).await.unwrap();
let result = handler.revoke(&key).await;
assert!(
matches!(result, Err(GarrisonError::Internal(ref msg)) if msg.contains("apikey-deserialize")),
"无效 JSON 应返回 Internal 错误,实际: {:?}",
result
);
}
#[test]
fn e4_idx_key_for_returns_correct_format() {
let key = "abcd1234".repeat(8); let idx_key = super::handler::idx_key_for(&key);
assert_eq!(
idx_key,
format!("garrison:apikey:idx:{}", key),
"E4: 索引 key 格式应为 garrison:apikey:idx:<key>"
);
}
#[test]
fn e4_source_verify_revoke_have_no_keys_scan() {
let source = include_str!("handler.rs");
let code_only: String = source
.lines()
.filter(|line| {
let trimmed = line.trim_start();
!(trimmed.starts_with("//!") || trimmed.starts_with("///") || trimmed.starts_with("//"))
})
.collect::<Vec<_>>()
.join("\n");
assert!(
!code_only.contains("\"garrison:apikey:*:"),
"E4: handler.rs 代码不应再使用 garrison:apikey:*: 通配符扫描模式(verify/revoke 旧路径)"
);
assert!(
code_only.contains("idx_key_for"),
"E4: handler.rs 代码应使用 idx_key_for 构造反向索引 key"
);
assert!(
code_only.contains("garrison:apikey:idx:"),
"E4: handler.rs 代码应包含 garrison:apikey:idx: 索引 key 前缀"
);
}
#[tokio::test]
#[serial_test::serial]
async fn e4_generate_with_namespace_writes_reverse_index() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let key = handler
.generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
.await
.unwrap();
let idx_key = format!("garrison:apikey:idx:{}", key);
let idx_value = dao.get(&idx_key).await.unwrap();
assert!(
idx_value.is_some(),
"E4: 反向索引 garrison:apikey:idx:<key> 应存在"
);
let expected_dao_key = format!("garrison:apikey:internal:{}", key);
assert_eq!(
idx_value.unwrap(),
expected_dao_key,
"E4: 索引 value 应为 dao_key(garrison:apikey:<namespace>:<key>)"
);
}
#[tokio::test]
#[serial_test::serial]
async fn e4_generate_writes_reverse_index_default_namespace() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let key = handler.generate("1001", vec![], 3600).await.unwrap();
let idx_key = format!("garrison:apikey:idx:{}", key);
let idx_value = dao.get(&idx_key).await.unwrap();
assert!(idx_value.is_some(), "E4: 默认 generate 也应写入反向索引");
let expected_dao_key = format!("garrison:apikey:default:{}", key);
assert_eq!(
idx_value.unwrap(),
expected_dao_key,
"E4: 默认 namespace 的索引 value 应为 garrison:apikey:default:<key>"
);
}
#[tokio::test]
#[serial_test::serial]
async fn e4_verify_uses_reverse_index() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
for i in 0..50 {
let noise_key = format!("garrison:apikey:noise:{}:{}", i, "a".repeat(64));
dao.set(&noise_key, "noise", 3600).await.unwrap();
}
let key = handler
.generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
.await
.unwrap();
let info = handler.verify(&key).await.unwrap();
assert_eq!(info.login_id, "1001");
assert_eq!(info.namespace, "internal");
}
#[tokio::test]
#[serial_test::serial]
async fn e4_revoke_uses_reverse_index() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let key = handler
.generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
.await
.unwrap();
handler.revoke(&key).await.unwrap();
let result = handler.verify(&key).await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"E4: revoke 后 verify 应返回 InvalidToken"
);
}
#[tokio::test]
#[serial_test::serial]
async fn e4_verify_falls_back_to_legacy_format() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let key = "deadbeef".repeat(8); let old_dao_key = format!("garrison:apikey:{}", key);
let info = ApiKeyInfo {
login_id: "legacy-user".to_string(),
scopes: vec!["legacy".into()],
expire_at: SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs() as i64
+ 3600,
revoked: false,
namespace: "default".to_string(),
};
let value = serde_json::to_string(&info).unwrap();
dao.set(&old_dao_key, &value, 3600).await.unwrap();
let verified = handler.verify(&key).await.unwrap();
assert_eq!(
verified.login_id, "legacy-user",
"E4: 无索引时应回退到旧格式 garrison:apikey:<key>"
);
}
#[tokio::test]
#[serial_test::serial]
async fn e4_revoke_falls_back_to_legacy_format() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let key = "cafebeef".repeat(8);
let old_dao_key = format!("garrison:apikey:{}", key);
let info = ApiKeyInfo {
login_id: "legacy-revoke".to_string(),
scopes: vec![],
expire_at: SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs() as i64
+ 3600,
revoked: false,
namespace: "default".to_string(),
};
let value = serde_json::to_string(&info).unwrap();
dao.set(&old_dao_key, &value, 3600).await.unwrap();
handler.revoke(&key).await.unwrap();
let result = handler.verify(&key).await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"E4: revoke 旧格式 key 后 verify 应失败"
);
}
#[tokio::test]
#[serial_test::serial]
async fn e4_index_has_same_ttl_as_key() {
let dao = Arc::new(crate::dao::tests::MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let timeout = 3600i64;
let key = handler
.generate_with_namespace("ttl-test", "internal", vec![], timeout)
.await
.unwrap();
let dao_key = format!("garrison:apikey:internal:{}", key);
let idx_key = format!("garrison:apikey:idx:{}", key);
let key_ttl = dao.get_timeout(&dao_key).await.unwrap();
let idx_ttl = dao.get_timeout(&idx_key).await.unwrap();
assert!(key_ttl.is_some(), "E4: 主 key 应有 TTL");
assert!(idx_ttl.is_some(), "E4: 反向索引应有 TTL(与主 key 一致)");
let key_secs = key_ttl.unwrap().as_secs();
let idx_secs = idx_ttl.unwrap().as_secs();
assert!(
key_secs <= timeout as u64,
"E4: 主 key TTL 应 ≤ {},实际: {}",
timeout,
key_secs
);
assert!(
idx_secs <= timeout as u64,
"E4: 索引 TTL 应 ≤ {},实际: {}",
timeout,
idx_secs
);
let diff = key_secs.abs_diff(idx_secs);
assert!(
diff <= 2,
"E4: 主 key 与索引的 TTL 差距应 ≤ 2s,实际: {}s",
diff
);
}
#[tokio::test]
#[serial_test::serial]
async fn e4_rotate_writes_index_for_new_key() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let old_key = handler
.generate("1001", vec!["read".into()], 3600)
.await
.unwrap();
let new_key = handler.rotate(&old_key).await.unwrap();
assert_ne!(old_key, new_key);
let old_result = handler.verify(&old_key).await;
assert!(old_result.is_err(), "old_key 应被吊销");
let info = handler.verify(&new_key).await.unwrap();
assert_eq!(info.login_id, "1001");
let new_idx_key = format!("garrison:apikey:idx:{}", new_key);
let idx_value = dao.get(&new_idx_key).await.unwrap();
assert!(idx_value.is_some(), "E4: rotate 后新 key 的反向索引应存在");
}
#[tokio::test]
#[serial_test::serial]
async fn e4_multiple_namespaces_all_indexed() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let k1 = handler
.generate_with_namespace("1001", "internal", vec![], 3600)
.await
.unwrap();
let k2 = handler
.generate_with_namespace("2002", "partner", vec![], 3600)
.await
.unwrap();
let k3 = handler
.generate_with_namespace("3003", "default", vec![], 3600)
.await
.unwrap();
for (key, ns) in &[(&k1, "internal"), (&k2, "partner"), (&k3, "default")] {
let idx_key = format!("garrison:apikey:idx:{}", key);
let idx_value = dao.get(&idx_key).await.unwrap();
assert!(
idx_value.is_some(),
"E4: namespace={} 的 key 反向索引应存在",
ns
);
let expected_dao_key = format!("garrison:apikey:{}:{}", ns, key);
assert_eq!(
idx_value.unwrap(),
expected_dao_key,
"E4: namespace={} 的索引 value 应为 {}",
ns,
expected_dao_key
);
}
assert_eq!(handler.verify(&k1).await.unwrap().login_id, "1001");
assert_eq!(handler.verify(&k2).await.unwrap().login_id, "2002");
assert_eq!(handler.verify(&k3).await.unwrap().login_id, "3003");
}
#[tokio::test]
async fn e4_verify_nonexistent_key_returns_invalid_token() {
let handler = make_handler();
let result = handler.verify("nonexistent-key-12345").await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"E4: 不存在的 key 应返回 InvalidToken(无扫描),实际: {:?}",
result
);
}
#[tokio::test]
async fn e4_revoke_nonexistent_key_returns_invalid_token() {
let handler = make_handler();
let result = handler.revoke("nonexistent-key-67890").await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"E4: 不存在的 key 应返回 InvalidToken(无扫描),实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn e4_verify_falls_through_when_dao_key_deleted() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let key = handler
.generate_with_namespace("1001", "internal", vec![], 3600)
.await
.unwrap();
let dao_key = format!("garrison:apikey:internal:{}", key);
dao.delete(&dao_key).await.unwrap();
let result = handler.verify(&key).await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"E4: 索引存在但主 key 已删除时应返回 InvalidToken,实际: {:?}",
result
);
}