use crate::error::BaseError;
use crate::token::TokenManager;
use jsonwebtoken::Algorithm;
use serde_json::json;
#[test]
fn test_symmetric_token_generation_and_verification() {
let manager = TokenManager::new_symmetric(
"test_secret_key_12345",
Algorithm::HS256,
"test-issuer".to_string(),
"test-audience".to_string(),
3600, 86400, );
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_key",
algorithm,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
);
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_secret",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
);
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_secret",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
);
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");
}
#[test]
fn test_token_verification_with_wrong_secret() {
let manager_a = TokenManager::new_symmetric(
"secret_key_a",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
);
let token = manager_a
.generate_access_token("user_test", json!({}))
.expect("生成 Token 失败");
let manager_b = TokenManager::new_symmetric(
"secret_key_b",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
);
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_key",
Algorithm::HS256,
"issuer_a".to_string(),
"audience".to_string(),
3600,
86400,
);
let token = manager_a
.generate_access_token("user_test", json!({}))
.expect("生成 Token 失败");
let manager_b = TokenManager::new_symmetric(
"secret_key",
Algorithm::HS256,
"issuer_b".to_string(),
"audience".to_string(),
3600,
86400,
);
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_key",
Algorithm::HS256,
"issuer".to_string(),
"audience_a".to_string(),
3600,
86400,
);
let token = manager_a
.generate_access_token("user_test", json!({}))
.expect("生成 Token 失败");
let manager_b = TokenManager::new_symmetric(
"secret_key",
Algorithm::HS256,
"issuer".to_string(),
"audience_b".to_string(),
3600,
86400,
);
let result = manager_b.verify_token(&token);
assert!(result.is_err());
}
#[test]
fn test_token_expiration() {
let manager = TokenManager::new_symmetric(
"test_secret",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3, 86400,
);
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_secret",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3, 86400,
);
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_secret",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
10, 86400,
);
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 依赖黑名单查询)"]
async fn test_refresh_access_token() {
let manager = TokenManager::new_symmetric(
"test_secret",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
);
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]
#[ignore = "需要 Redis(verify_token_checked 依赖黑名单查询)"]
async fn test_refresh_with_access_token_should_fail() {
let manager = TokenManager::new_symmetric(
"test_secret",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
);
let access_token = manager
.generate_access_token("user_test", json!({}))
.expect("生成 Access Token 失败");
let result = manager.refresh_access_token(&access_token, json!({})).await;
assert!(result.is_err());
assert!(
matches!(result, Err(BaseError::TokenTypeInvalid(ref msg)) if msg.contains("refresh")),
"期望 TokenTypeInvalid 错误,实际: {:?}",
result
);
}
#[test]
fn test_custom_claims_serialization() {
let manager = TokenManager::new_symmetric(
"test_secret",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
);
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_secret",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
);
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_secret",
Algorithm::HS256,
"issuer".to_string(),
"audience".to_string(),
3600,
86400,
);
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);
}