use crate::error::BaseError;
use crate::token::manager::REVOCATION_WATERMARK_MIN_TTL_SECONDS;
use crate::token::TokenManager;
use jsonwebtoken::Algorithm;
use serde_json::json;
const ACTIVE_SECRET: &str = "active-secret-0123456789abcdef0123456789abcdef";
const RETIRING_SECRET: &str = "retiring-secret-0123456789abcdef0123456789abcdef";
#[test]
fn test_symmetric_token_generation_and_verification() {
let manager = TokenManager::new_symmetric(
"test_secret_key_12345xxxxxxxxxxx",
Algorithm::HS256,
"test-issuer".to_string(),
"test-audience".to_string(),
3600, 86400, )
.expect("测试 TokenManager 应构建成功");
let custom_claims = json!({
"role": "admin",
"permissions": ["read", "write", "delete"]
});
let token = manager
.generate_access_token("user_123", custom_claims.clone())
.expect("生成 Token 失败");
assert!(!token.is_empty());
let claims = manager.verify_token(&token).expect("验证 Token 失败");
assert_eq!(claims.iss, "test-issuer");
assert_eq!(claims.sub, "user_123");
assert_eq!(claims.aud, "test-audience");
assert_eq!(claims.token_type, crate::token::TokenType::Access);
assert_eq!(claims.custom.get("role").unwrap(), "admin");
assert_eq!(
claims.custom.get("permissions").unwrap(),
&json!(["read", "write", "delete"])
);
}
#[test]
fn test_symmetric_algorithms() {
let algorithms = vec![Algorithm::HS256, Algorithm::HS384, Algorithm::HS512];
for algorithm in algorithms {
let manager = TokenManager::new_symmetric(
"test_secret_keyxxxxxxxxxxxxxxxxx",
algorithm,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let token = manager
.generate_access_token("user_test", json!({}))
.expect("生成 Token 失败");
let claims = manager.verify_token(&token).expect("验证 Token 失败");
assert_eq!(claims.sub, "user_test");
}
}
#[test]
fn test_refresh_token_generation() {
let manager = TokenManager::new_symmetric(
"test_secretxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let refresh_token = manager
.generate_refresh_token("user_456")
.expect("生成 Refresh Token 失败");
let claims = manager
.verify_token(&refresh_token)
.expect("验证 Refresh Token 失败");
assert_eq!(claims.token_type, crate::token::TokenType::Refresh);
assert_eq!(claims.sub, "user_456");
assert!(claims.custom.is_null() || claims.custom.as_object().unwrap().is_empty());
}
#[test]
fn test_token_pair_generation() {
let manager = TokenManager::new_symmetric(
"test_secretxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let custom_claims = json!({"role": "user"});
let (access_token, refresh_token) = manager
.generate_token_pair("user_789", custom_claims)
.expect("生成 Token 对失败");
let access_claims = manager
.verify_token(&access_token)
.expect("验证 Access Token 失败");
assert_eq!(access_claims.token_type, crate::token::TokenType::Access);
assert_eq!(access_claims.sub, "user_789");
let refresh_claims = manager
.verify_token(&refresh_token)
.expect("验证 Refresh Token 失败");
assert_eq!(refresh_claims.token_type, crate::token::TokenType::Refresh);
assert_eq!(refresh_claims.sub, "user_789");
assert!(
refresh_claims.custom.is_null()
|| refresh_claims
.custom
.as_object()
.is_some_and(serde_json::Map::is_empty),
"旧入口必须保持 Refresh Token 无自定义声明的兼容语义"
);
}
#[test]
fn keyring_signs_with_active_kid_and_verifies_active_token() {
let manager = TokenManager::new_symmetric_keyring(
"2026-07-active".to_string(),
ACTIVE_SECRET,
Vec::new(),
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("合法 keyring 应构建成功");
let token = manager
.generate_access_token("user-keyring", json!({}))
.expect("active key 应签发成功");
let header = jsonwebtoken::decode_header(&token).expect("签发结果应有合法 Header");
assert_eq!(header.kid.as_deref(), Some("2026-07-active"));
assert_eq!(
manager
.verify_token(&token)
.expect("active key Token 应验证成功")
.sub,
"user-keyring"
);
}
#[test]
fn rotated_keyring_accepts_retiring_token_but_never_signs_with_retiring_key() {
let previous = TokenManager::new_symmetric_keyring(
"2026-06-retiring".to_string(),
RETIRING_SECRET,
Vec::new(),
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("旧 keyring 应构建成功");
let old_token = previous
.generate_refresh_token("user-rotation")
.expect("旧 active key 应签发成功");
let rotated = TokenManager::new_symmetric_keyring(
"2026-07-active".to_string(),
ACTIVE_SECRET,
vec![("2026-06-retiring".to_string(), RETIRING_SECRET.to_string())],
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("轮换后 keyring 应构建成功");
assert_eq!(
rotated
.verify_token(&old_token)
.expect("retiring key 应验证存量 Token")
.sub,
"user-rotation"
);
let new_token = rotated
.generate_refresh_token("user-rotation")
.expect("新 active key 应签发成功");
assert_eq!(
jsonwebtoken::decode_header(&new_token)
.expect("新 Token Header 应合法")
.kid
.as_deref(),
Some("2026-07-active")
);
assert!(
previous.verify_token(&new_token).is_err(),
"旧 keyring 不得验证未知的新 kid"
);
}
#[test]
fn keyring_fails_closed_for_missing_or_unknown_kid() {
let keyring = TokenManager::new_symmetric_keyring(
"known".to_string(),
ACTIVE_SECRET,
Vec::new(),
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("keyring 应构建成功");
let legacy = TokenManager::new_symmetric(
ACTIVE_SECRET,
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let unknown = TokenManager::new_symmetric_keyring(
"unknown".to_string(),
ACTIVE_SECRET,
Vec::new(),
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("未知 kid 的独立 keyring 应构建成功");
let missing_kid = legacy
.generate_access_token("user", json!({}))
.expect("legacy Token 应签发成功");
let unknown_kid = unknown
.generate_access_token("user", json!({}))
.expect("未知 kid Token 应签发成功");
assert!(matches!(
keyring.verify_token(&missing_kid),
Err(BaseError::TokenVerifyFailed(_))
));
assert!(matches!(
keyring.verify_token(&unknown_kid),
Err(BaseError::TokenVerifyFailed(_))
));
}
#[test]
fn keyring_rejects_weak_ambiguous_or_unbounded_keys() {
let build = |active_id: &str, active_secret: &str, retiring_keys| {
TokenManager::new_symmetric_keyring(
active_id.to_string(),
active_secret,
retiring_keys,
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
};
assert!(build("contains space", ACTIVE_SECRET, Vec::new()).is_err());
assert!(build("active", "short-secret", Vec::new()).is_err());
assert!(build(
"active",
ACTIVE_SECRET,
vec![("active".to_string(), RETIRING_SECRET.to_string())]
)
.is_err());
let excessive = (0..8)
.map(|index| (format!("retiring-{index}"), RETIRING_SECRET.to_string()))
.collect();
assert!(build("active", ACTIVE_SECRET, excessive).is_err());
assert!(TokenManager::new_symmetric_keyring(
"active".to_string(),
ACTIVE_SECRET,
Vec::new(),
Algorithm::RS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.is_err());
}
#[test]
fn keyring_debug_reports_shape_without_secret_material() {
let manager = TokenManager::new_symmetric_keyring(
"active".to_string(),
ACTIVE_SECRET,
vec![("retiring".to_string(), RETIRING_SECRET.to_string())],
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("keyring 应构建成功");
let debug = format!("{manager:?}");
assert!(debug.contains("keyring"));
assert!(debug.contains("verification_key_count: 2"));
assert!(!debug.contains(ACTIVE_SECRET));
assert!(!debug.contains(RETIRING_SECRET));
}
#[test]
fn test_token_pair_with_distinct_claims() {
let manager = TokenManager::new_symmetric(
"test_secretxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let (access_token, refresh_token) = manager
.generate_token_pair_with_refresh_claims(
"user_790",
json!({
"authz_version": 7,
"roles": ["admin"],
"permissions": ["users:write"]
}),
json!({"authz_version": 7}),
)
.expect("生成带独立声明的 Token 对失败");
let access_claims = manager
.verify_token(&access_token)
.expect("验证 Access Token 失败");
let refresh_claims = manager
.verify_token(&refresh_token)
.expect("验证 Refresh Token 失败");
assert_eq!(access_claims.custom["authz_version"], 7);
assert_eq!(access_claims.custom["roles"], json!(["admin"]));
assert_eq!(refresh_claims.custom["authz_version"], 7);
assert!(
refresh_claims.custom.get("roles").is_none(),
"Refresh Token 不应复制角色等完整授权声明"
);
}
#[test]
fn test_token_verification_with_wrong_secret() {
let manager_a = TokenManager::new_symmetric(
"secret_key_axxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let token = manager_a
.generate_access_token("user_test", json!({}))
.expect("生成 Token 失败");
let manager_b = TokenManager::new_symmetric(
"secret_key_bxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let result = manager_b.verify_token(&token);
assert!(result.is_err());
if let Err(BaseError::TokenVerifyFailed(ref err)) = result {
let msg = err.to_string();
assert!(msg.contains("signature") || msg.contains("Invalid"));
}
assert!(
matches!(result, Err(BaseError::TokenVerifyFailed(_))),
"期望 TokenVerifyFailed 错误,实际: {:?}",
result
);
}
#[test]
fn test_token_verification_with_wrong_issuer() {
let manager_a = TokenManager::new_symmetric(
"secret_keyxxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer_a".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let token = manager_a
.generate_access_token("user_test", json!({}))
.expect("生成 Token 失败");
let manager_b = TokenManager::new_symmetric(
"secret_keyxxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer_b".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let result = manager_b.verify_token(&token);
assert!(result.is_err());
}
#[test]
fn test_token_verification_with_wrong_audience() {
let manager_a = TokenManager::new_symmetric(
"secret_keyxxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience_a".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let token = manager_a
.generate_access_token("user_test", json!({}))
.expect("生成 Token 失败");
let manager_b = TokenManager::new_symmetric(
"secret_keyxxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience_b".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let result = manager_b.verify_token(&token);
assert!(result.is_err());
}
#[test]
fn test_token_expiration() {
let manager = TokenManager::new_symmetric(
"test_secretxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3, 86400,
)
.expect("测试 TokenManager 应构建成功");
let token = manager
.generate_access_token("user_test", json!({}))
.expect("生成 Token 失败");
assert!(manager.verify_token(&token).is_ok());
std::thread::sleep(std::time::Duration::from_secs(5));
let result = manager.verify_token(&token);
assert!(result.is_err(), "Token 应该已过期但验证仍然成功");
if let Err(BaseError::TokenExpired) = &result {
}
assert!(
matches!(result, Err(BaseError::TokenExpired)),
"期望 TokenExpired 错误,实际: {:?}",
result
);
}
#[allow(deprecated)]
#[allow(clippy::expect_used)]
#[test]
fn test_parse_token_unsafe() {
let manager = TokenManager::new_symmetric(
"test_secretxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3, 86400,
)
.expect("测试 TokenManager 应构建成功");
let custom_claims = json!({"role": "admin"});
let token = manager
.generate_access_token("user_test", custom_claims)
.expect("生成 Token 失败");
std::thread::sleep(std::time::Duration::from_secs(5));
assert!(
manager.verify_token(&token).is_err(),
"Token 应该已过期但验证仍然成功"
);
let claims = manager.parse_token_unsafe(&token).expect("解析 Token 失败");
assert_eq!(claims.sub, "user_test");
assert_eq!(claims.custom.get("role").unwrap(), "admin");
}
#[test]
fn test_is_token_expiring_soon() {
let manager = TokenManager::new_symmetric(
"test_secretxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
10, 86400,
)
.expect("测试 TokenManager 应构建成功");
let token = manager
.generate_access_token("user_test", json!({}))
.expect("生成 Token 失败");
let expiring_soon = manager
.is_token_expiring_soon(&token, 20)
.expect("检查失败");
assert!(expiring_soon);
let expiring_soon = manager.is_token_expiring_soon(&token, 5).expect("检查失败");
assert!(!expiring_soon);
}
#[tokio::test]
#[ignore = "需要 Redis(verify_token_checked 依赖黑名单查询)"]
#[allow(deprecated)]
async fn test_refresh_access_token() {
let manager = TokenManager::new_symmetric(
"test_secretxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let refresh_token = manager
.generate_refresh_token("user_test")
.expect("生成 Refresh Token 失败");
let new_access_token = manager
.refresh_access_token(&refresh_token, json!({"role": "user"}))
.await
.expect("刷新 Access Token 失败");
let claims = manager
.verify_token(&new_access_token)
.expect("验证新 Access Token 失败");
assert_eq!(claims.token_type, crate::token::TokenType::Access);
assert_eq!(claims.sub, "user_test");
assert_eq!(claims.custom.get("role").unwrap(), "user");
}
#[tokio::test]
#[allow(deprecated)]
async fn test_refresh_with_access_token_should_fail() {
let manager = TokenManager::new_symmetric(
"test_secretxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let access_token = manager
.generate_access_token("user_test", json!({}))
.expect("生成 Access Token 失败");
let result = manager.refresh_access_token(&access_token, json!({})).await;
assert!(
matches!(result, Err(BaseError::TokenTypeInvalid(_))),
"期望 TokenTypeInvalid 错误,实际: {:?}",
result
);
}
#[tokio::test]
async fn test_verify_token_checked_type_mismatch_fails_before_redis() {
let manager = TokenManager::new_symmetric(
"test_secretxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let access_token = manager
.generate_access_token("user_test", json!({}))
.expect("生成 Access Token 失败");
let result = manager
.verify_token_checked(&access_token, crate::token::TokenType::Refresh)
.await;
assert!(
matches!(result, Err(BaseError::TokenTypeInvalid(_))),
"类型不匹配必须先于 Redis 查询被拒绝,实际: {:?}",
result
);
}
#[test]
fn test_new_symmetric_enforces_hmac_secret_min_bytes() {
let build = |secret: &str| {
TokenManager::new_symmetric(
secret,
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
};
let err = build(&"x".repeat(31)).expect_err("31 字节密钥必须被拒绝");
assert!(
matches!(err, BaseError::TokenKeyInvalid(_)),
"弱密钥必须返回 TokenKeyInvalid,实际: {err:?}"
);
build(&"x".repeat(32)).expect("32 字节密钥应构建成功");
build(&"x".repeat(33)).expect("33 字节密钥应构建成功");
assert!(build(&"中".repeat(10)).is_err(), "30 字节必须被拒绝");
build(&"中".repeat(11)).expect("33 字节(多字节字符)应构建成功");
}
#[test]
fn test_new_symmetric_rejects_non_hmac_algorithm() {
let result = TokenManager::new_symmetric(
&"x".repeat(32),
Algorithm::RS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
);
assert!(
matches!(result, Err(BaseError::TokenKeyInvalid(_))),
"非 HMAC 算法必须返回 TokenKeyInvalid,实际: {result:?}"
);
}
#[test]
fn test_revocation_watermark_ttl_covers_longest_token_lifetime() {
let normal = TokenManager::new_symmetric(
&"x".repeat(32),
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("正常配置应构建成功");
assert_eq!(
normal.revocation_watermark_ttl(),
REVOCATION_WATERMARK_MIN_TTL_SECONDS,
"短配置也必须保留固定下限,覆盖配置缩短前的存量 Token"
);
let access_longer = TokenManager::new_symmetric(
&"x".repeat(32),
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
86400,
3600,
)
.expect("access>refresh 仍应构建成功");
assert_eq!(
access_longer.revocation_watermark_ttl(),
REVOCATION_WATERMARK_MIN_TTL_SECONDS,
"access>refresh 时同样不得低于固定下限"
);
let longer_than_floor = TokenManager::new_symmetric(
&"x".repeat(32),
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
REVOCATION_WATERMARK_MIN_TTL_SECONDS + 1,
)
.expect("超过固定下限的 Refresh 有效期仍应构建成功");
assert_eq!(
longer_than_floor.revocation_watermark_ttl(),
REVOCATION_WATERMARK_MIN_TTL_SECONDS + 1,
"消费者配置更长时必须取配置值,不能被固定下限缩短"
);
}
#[tokio::test]
async fn test_rotate_expired_refresh_returns_expired_not_family_revocation() {
let manager = TokenManager::new_symmetric(
"test_secretxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("系统时钟应正常")
.as_secs();
let expired_claims = crate::token::TokenClaims {
iss: "issuer".to_string(),
sub: "user_test".to_string(),
aud: "audience".to_string(),
exp: now.saturating_sub(1),
nbf: now.saturating_sub(3600),
iat: now.saturating_sub(3600),
jti: "expired-jti".to_string(),
token_type: crate::token::TokenType::Refresh,
custom: serde_json::Value::Null,
};
let result = manager
.rotate_refresh_token_from_claims(&expired_claims, json!({}))
.await;
assert!(
matches!(result, Err(BaseError::TokenExpired)),
"过期 Token 轮换必须返回 TokenExpired 而非触发家族撤销,实际: {:?}",
result
);
}
#[test]
fn test_custom_claims_serialization() {
let manager = TokenManager::new_symmetric(
"test_secretxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let custom_claims = json!({
"user_id": 12345,
"username": "john_doe",
"email": "john@example.com",
"roles": ["admin", "user"],
"permissions": {
"read": true,
"write": true,
"delete": false
},
"metadata": {
"last_login": "2024-01-01T00:00:00Z",
"login_count": 42
}
});
let token = manager
.generate_access_token("user_12345", custom_claims.clone())
.expect("生成 Token 失败");
let claims = manager.verify_token(&token).expect("验证 Token 失败");
assert_eq!(claims.custom.get("user_id").unwrap(), 12345);
assert_eq!(claims.custom.get("username").unwrap(), "john_doe");
assert_eq!(claims.custom.get("email").unwrap(), "john@example.com");
assert_eq!(
claims.custom.get("roles").unwrap(),
&json!(["admin", "user"])
);
let permissions = claims.custom.get("permissions").unwrap();
assert_eq!(permissions.get("read").unwrap(), true);
assert_eq!(permissions.get("write").unwrap(), true);
assert_eq!(permissions.get("delete").unwrap(), false);
let metadata = claims.custom.get("metadata").unwrap();
assert_eq!(metadata.get("last_login").unwrap(), "2024-01-01T00:00:00Z");
assert_eq!(metadata.get("login_count").unwrap(), 42);
}
#[test]
fn test_empty_custom_claims() {
let manager = TokenManager::new_symmetric(
"test_secretxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let token = manager
.generate_access_token("user_test", json!({}))
.expect("生成 Token 失败");
let claims = manager.verify_token(&token).expect("验证 Token 失败");
assert!(claims.custom.is_object());
assert_eq!(claims.custom.as_object().unwrap().len(), 0);
}
#[test]
fn test_jti_uniqueness() {
let manager = TokenManager::new_symmetric(
"test_secretxxxxxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
let token1 = manager
.generate_access_token("user_test", json!({}))
.expect("生成 Token 1 失败");
let token2 = manager
.generate_access_token("user_test", json!({}))
.expect("生成 Token 2 失败");
let token3 = manager
.generate_access_token("user_test", json!({}))
.expect("生成 Token 3 失败");
let claims1 = manager.verify_token(&token1).expect("验证 Token 1 失败");
let claims2 = manager.verify_token(&token2).expect("验证 Token 2 失败");
let claims3 = manager.verify_token(&token3).expect("验证 Token 3 失败");
assert_ne!(claims1.jti, claims2.jti);
assert_ne!(claims1.jti, claims3.jti);
assert_ne!(claims2.jti, claims3.jti);
}