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).with_allow_global_verify(true)
}
fn key_id_of(token: &str) -> &str {
token
.split_once('.')
.expect("token 应为 key_id.key_secret 双段格式")
.0
}
#[test]
fn new_creates_handler() {
let _handler = make_handler();
}
#[tokio::test]
async fn generate_returns_dual_segment_format() {
let handler = make_handler();
let key = handler
.generate("1001", vec!["read".into()], 3600)
.await
.unwrap();
let (key_id, key_secret) = key
.split_once('.')
.expect("应为 key_id.key_secret 双段格式");
assert_eq!(key_id.len(), 32);
assert_eq!(key_secret.len(), 32);
assert!(key_id.chars().all(|c| c.is_ascii_hexdigit()));
assert!(key_secret.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()).with_allow_global_verify(true);
let key = handler
.generate("1001", vec!["read".into()], 3600)
.await
.unwrap();
let dao_key = format!("garrison:apikey:default:{}", key_id_of(&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_eq!(result.unwrap(), (), "撤销存在的 API key 应返回 Ok(())");
let verify_result = handler.verify(&key).await;
assert!(
matches!(verify_result, Err(GarrisonError::InvalidToken(_))),
"已吊销 key verify 应返回 InvalidToken,实际: {:?}",
verify_result
);
}
#[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!(
new_key.contains('.'),
"新 key 应为 key_id.key_secret 双段格式"
);
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(),
..Default::default()
};
let json = serde_json::to_string(&info).unwrap();
assert!(json.contains("\"namespace\""), "JSON 应包含 namespace 字段");
assert!(json.contains("\"internal\""), "namespace 值应为 internal");
}
#[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()).with_allow_global_verify(true);
let key = handler
.generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
.await
.unwrap();
let dao_key = format!("garrison:apikey:internal:{}", key_id_of(&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 ns_less_key = format!("garrison:apikey:{}", key_id_of(&key));
let ns_less_value = dao.get(&ns_less_key).await.unwrap();
assert!(ns_less_value.is_none(), "无 namespace 的存储路径不应存在");
}
#[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()).with_allow_global_verify(true);
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()).with_allow_global_verify(true);
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()).with_allow_global_verify(true);
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", "idx", vec![], 3600)
.await;
assert!(
matches!(r, Err(GarrisonError::InvalidParam(_))),
"保留 namespace idx 应报错(防与反向索引键碰撞导致数据覆盖)"
);
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 应通过");
}
#[cfg(feature = "listener")]
#[test]
fn public_key_ref_never_exposes_secret() {
use super::handler::public_key_ref;
let key_id = "a".repeat(32);
let key_secret = "b".repeat(32);
let full = format!("{}.{}", key_id, key_secret);
let redacted = public_key_ref(&full);
assert_eq!(redacted, key_id, "双段格式应只返回 key_id");
assert!(
!redacted.contains(&key_secret),
"脱敏结果绝不得含 key_secret"
);
let undotted = "deadbeef".repeat(8); let redacted_undotted = public_key_ref(&undotted);
assert_eq!(
redacted_undotted, "deadbeef\u{2026}",
"不含 `.` 的输入应截断为前 8 字符 + …"
);
assert!(
redacted_undotted.chars().count() <= 9,
"脱敏后长度应远小于原始输入,不足以还原"
);
}
#[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()).with_allow_global_verify(true);
let key = handler
.generate_with_namespace("1001", "internal", vec![], 3600)
.await
.unwrap();
let key_id = key_id_of(&key);
let dao_key = format!("garrison:apikey:internal:{}", key_id);
let value = dao.get(&dao_key).await.unwrap().unwrap();
let mut info: ApiKeyInfo = serde_json::from_str(&value).unwrap();
info.namespace = "other".to_string();
let tampered_value = serde_json::to_string(&info).unwrap();
dao.set(&dao_key, &tampered_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()).with_allow_global_verify(true);
let key_id = "deadbeefdeadbeefdeadbeefdeadbeef"; let key_secret = "0123456789abcdef0123456789abcdef";
let token = format!("{}.{}", key_id, key_secret);
let dao_key = format!("garrison:apikey:default:{}", key_id);
dao.set(&super::handler::idx_key_for(key_id), &dao_key, 3600)
.await
.unwrap();
dao.set(&dao_key, "invalid-json", 3600).await.unwrap();
let result = handler.verify(&token).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()).with_allow_global_verify(true);
let key_id = "cafebeefcafebeefcafebeefcafebeef"; let key_secret = "0123456789abcdef0123456789abcdef";
let token = format!("{}.{}", key_id, key_secret);
let dao_key = format!("garrison:apikey:default:{}", key_id);
dao.set(&super::handler::idx_key_for(key_id), &dao_key, 3600)
.await
.unwrap();
dao.set(&dao_key, "invalid-json", 3600).await.unwrap();
let result = handler.revoke(&token).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()).with_allow_global_verify(true);
let key = handler
.generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
.await
.unwrap();
let idx_key = format!("garrison:apikey:idx:{}", key_id_of(&key));
let idx_value = dao.get(&idx_key).await.unwrap();
assert!(
idx_value.is_some(),
"E4: 反向索引 garrison:apikey:idx:<key_id> 应存在"
);
let expected_dao_key = format!("garrison:apikey:internal:{}", key_id_of(&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()).with_allow_global_verify(true);
let key = handler.generate("1001", vec![], 3600).await.unwrap();
let idx_key = format!("garrison:apikey:idx:{}", key_id_of(&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_id_of(&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()).with_allow_global_verify(true);
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()).with_allow_global_verify(true);
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_index_has_same_ttl_as_key() {
let dao = Arc::new(crate::dao::tests::MockDao::new());
let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
let timeout = 3600i64;
let key = handler
.generate_with_namespace("ttl-test", "internal", vec![], timeout)
.await
.unwrap();
let dao_key = format!("garrison:apikey:internal:{}", key_id_of(&key));
let idx_key = format!("garrison:apikey:idx:{}", key_id_of(&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()).with_allow_global_verify(true);
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:{}", key_id_of(&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()).with_allow_global_verify(true);
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_id_of(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_id_of(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()).with_allow_global_verify(true);
let key = handler
.generate_with_namespace("1001", "internal", vec![], 3600)
.await
.unwrap();
let dao_key = format!("garrison:apikey:internal:{}", key_id_of(&key));
dao.delete(&dao_key).await.unwrap();
let result = handler.verify(&key).await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"E4: 索引存在但主 key 已删除时应返回 InvalidToken,实际: {:?}",
result
);
}
#[tokio::test]
#[serial_test::serial]
async fn stored_value_contains_no_plaintext_secret() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
let key = handler
.generate_with_namespace("1001", "internal", vec![], 3600)
.await
.unwrap();
let (key_id, key_secret) = key.split_once('.').unwrap();
let dao_key = format!("garrison:apikey:internal:{}", key_id);
let value = dao.get(&dao_key).await.unwrap().unwrap();
assert!(
!value.contains(key_secret),
"存储 value 不应包含明文 key_secret"
);
let info: ApiKeyInfo = serde_json::from_str(&value).unwrap();
assert_eq!(info.secret_hash.len(), 64, "secret_hash 应为 64 hex");
assert!(info.secret_hash.chars().all(|c| c.is_ascii_hexdigit()));
assert_ne!(info.secret_hash, *key_secret, "存储的应是哈希而非明文");
use sha2::{Digest, Sha256};
use std::fmt::Write;
let mut hasher = Sha256::new();
hasher.update(key_secret.as_bytes());
let mut expected_hash = String::with_capacity(64);
for byte in hasher.finalize() {
let _ = write!(expected_hash, "{:02x}", byte);
}
assert_eq!(
info.secret_hash, expected_hash,
"secret_hash 应等于 sha256(key_secret) 的 hex 编码"
);
}
#[tokio::test]
#[serial_test::serial]
async fn verify_rejects_wrong_secret() {
let handler = make_handler();
let key = handler.generate("1001", vec![], 3600).await.unwrap();
let (key_id, _) = key.split_once('.').unwrap();
let forged = format!("{}.{}", key_id, "f".repeat(32));
let result = handler.verify(&forged).await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(ref m)) if m == "apikey-secret-mismatch"),
"错误 secret 应返回 InvalidToken(secret-mismatch),实际: {:?}",
result
);
}
#[tokio::test]
async fn generate_sets_owner_id_to_login_id_by_default() {
let handler = make_handler();
let key = handler.generate("user-42", vec![], 3600).await.unwrap();
let info = handler.verify(&key).await.unwrap();
assert_eq!(info.owner_id.as_deref(), Some("user-42"));
}
#[tokio::test]
async fn generate_with_options_sets_explicit_owner_id() {
let handler = make_handler();
let key = handler
.generate_with_options(
"svc-account",
"internal",
vec![],
3600,
Some("team-a".to_string()),
Some(100),
)
.await
.unwrap();
let info = handler.verify(&key).await.unwrap();
assert_eq!(info.owner_id.as_deref(), Some("team-a"));
assert_eq!(info.rate_limit, Some(100));
}
#[tokio::test]
async fn generate_rejects_disallowed_scope() {
let handler = make_handler().with_allowed_scopes(vec![
ApiKeyScope::Read.as_str().to_string(),
ApiKeyScope::Write.as_str().to_string(),
]);
let ok = handler
.generate("1001", vec!["read".into(), "write".into()], 3600)
.await;
assert!(ok.is_ok(), "允许列表内的 scope 应通过");
let bad = handler.generate("1001", vec!["delete".into()], 3600).await;
assert!(
matches!(bad, Err(GarrisonError::InvalidParam(ref m)) if m.starts_with("apikey-scope-not-allowed::")),
"未知 scope 应返回 InvalidParam,实际: {:?}",
bad
);
}
#[tokio::test]
#[serial_test::serial]
async fn verify_tracks_last_used_when_enabled() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone())
.with_last_used_tracking(true)
.with_allow_global_verify(true);
let key = handler
.generate_with_namespace("1001", "internal", vec![], 3600)
.await
.unwrap();
let info0 = handler.verify(&key).await.unwrap();
let dao_key = format!("garrison:apikey:internal:{}", key_id_of(&key));
let stored: ApiKeyInfo =
serde_json::from_str(&dao.get(&dao_key).await.unwrap().unwrap()).unwrap();
assert!(
stored.last_used_at.is_some(),
"启用追踪后 verify 应记录 last_used_at"
);
let _ = info0;
}
#[tokio::test]
#[serial_test::serial]
async fn verify_does_not_track_last_used_by_default() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
let key = handler
.generate_with_namespace("1001", "internal", vec![], 3600)
.await
.unwrap();
handler.verify(&key).await.unwrap();
let dao_key = format!("garrison:apikey:internal:{}", key_id_of(&key));
let stored: ApiKeyInfo =
serde_json::from_str(&dao.get(&dao_key).await.unwrap().unwrap()).unwrap();
assert!(
stored.last_used_at.is_none(),
"默认不应记录 last_used_at(verify 只读)"
);
}
#[tokio::test]
#[serial_test::serial]
async fn get_keys_older_than_filters_by_last_used() {
let dao = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
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.update_last_used(&k2).await.unwrap();
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs() as i64;
let stale = handler.get_keys_older_than("internal", now).await.unwrap();
assert_eq!(stale.len(), 1, "仅 k1(从未使用)应被视为陈旧");
assert_eq!(stale[0].login_id, "1001");
}
#[tokio::test]
async fn verify_passes_without_max_age() {
let handler = make_handler();
let token = handler.generate("user1", vec![], 3600).await.unwrap();
let info = handler.verify(&token).await.unwrap();
assert!(info.created_at > 0, "新生成的 key 应有 created_at");
}
#[tokio::test]
async fn verify_passes_with_valid_max_age() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao)
.with_max_age(7200)
.with_allow_global_verify(true); let token = handler.generate("user1", vec![], 3600).await.unwrap();
let info = handler.verify(&token).await.unwrap();
assert!(info.created_at > 0);
}
#[tokio::test]
async fn verify_rejects_expired_max_age() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone())
.with_max_age(10)
.with_allow_global_verify(true); let token = handler.generate("user1", vec![], 3600).await.unwrap();
let key_id = key_id_of(&token);
let dao_key = format!("garrison:apikey:default:{}", key_id);
let mut info: ApiKeyInfo =
serde_json::from_str(&dao.get(&dao_key).await.unwrap().unwrap()).unwrap();
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs() as i64;
info.created_at = now - 100; dao.set(&dao_key, &serde_json::to_string(&info).unwrap(), 3600)
.await
.unwrap();
let err = handler.verify(&token).await.unwrap_err();
assert!(
matches!(err, GarrisonError::ExpiredToken(ref msg) if msg.contains("max-age")),
"超期 key 应返回 ExpiredToken(max-age),got: {:?}",
err
);
}
#[test]
fn apikey_info_requires_created_at_field() {
let json = r#"{"login_id":"1","scopes":[],"expire_at":0,"revoked":false,"namespace":"default","key_id":"a","secret_hash":"b"}"#;
let result = serde_json::from_str::<ApiKeyInfo>(json);
assert!(
result.is_err(),
"缺失 created_at 的 JSON 应反序列化失败,实际: {:?}",
result
);
}
#[tokio::test]
async fn global_verify_disabled_by_default() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let handler = ApiKeyHandler::new(dao.clone());
let key = handler
.generate_with_namespace("1001", "tenant-a", vec![], 3600)
.await
.unwrap();
let err = handler.verify(&key).await.unwrap_err();
assert!(
matches!(err, GarrisonError::InvalidParam(ref m) if m.contains("apikey-global-verify-disabled")),
"默认 verify() 应被禁用,实际: {}",
err
);
let info = handler
.verify_with_namespace(&key, "tenant-a")
.await
.unwrap();
assert_eq!(info.namespace, "tenant-a");
let relaxed = ApiKeyHandler::new(dao).with_allow_global_verify(true);
let info = relaxed.verify(&key).await.unwrap();
assert_eq!(info.namespace, "tenant-a");
}