use super::mock::MockDao;
use super::*;
use crate::error::GarrisonError;
use std::time::{SystemTime, UNIX_EPOCH};
const TEST_APP_SECRET: &str = "test-secret-key-with-32-bytes!!!";
fn make_handler() -> SignHandler {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
SignHandler::new("app-001", TEST_APP_SECRET, dao).unwrap()
}
fn now_ts() -> i64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs() as i64
}
#[test]
fn new_populates_fields() {
let handler = make_handler();
assert_eq!(handler.app_key(), "app-001");
assert_eq!(handler.timestamp_window(), 300);
}
#[test]
fn new_empty_app_key_returns_config_error() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let result = SignHandler::new("", TEST_APP_SECRET, dao);
assert!(result.is_err());
match result.err() {
Some(GarrisonError::Config(_)) => {},
other => panic!("期望 Config 错误,实际: {:?}", other),
}
}
#[test]
fn new_short_app_secret_returns_config_error() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let result = SignHandler::new("app-001", "short-secret", dao);
assert!(result.is_err());
match result.err() {
Some(GarrisonError::Config(msg)) => {
assert!(
msg.starts_with("sign-app-secret-too-short::"),
"错误消息应使用 i18n key 形式: {}",
msg
);
},
other => panic!("期望 Config 错误,实际: {:?}", other),
}
}
#[test]
fn new_app_secret_exactly_32_bytes_passes() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let secret_32 = "0123456789abcdef0123456789abcdef";
assert_eq!(secret_32.len(), 32);
let result = SignHandler::new("app-001", secret_32, dao);
assert!(result.is_ok());
}
#[test]
fn with_timestamp_window_sets_window() {
let handler = make_handler().with_timestamp_window(120);
assert_eq!(handler.timestamp_window(), 120);
}
#[test]
fn sign_returns_base64_string() {
let handler = make_handler();
let sig = handler.sign(
"POST",
"/api/v1/users",
1700000000,
"nonce-abc",
"e3b0c44298fc1c149afbf4c8996fb924",
);
assert_eq!(sig.len(), 44);
assert!(sig
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '+' || c == '/' || c == '='));
}
#[test]
fn sign_different_body_sha256_produces_different_signatures() {
let handler = make_handler();
let s1 = handler.sign("POST", "/api", 1700000000, "n", "aaa");
let s2 = handler.sign("POST", "/api", 1700000000, "n", "bbb");
assert_ne!(s1, s2);
}
#[test]
fn sign_different_method_produces_different_signatures() {
let handler = make_handler();
let s1 = handler.sign("GET", "/api", 1700000000, "n", "body");
let s2 = handler.sign("POST", "/api", 1700000000, "n", "body");
assert_ne!(s1, s2);
}
#[test]
fn sign_different_app_key_produces_different_signatures() {
let dao1: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let dao2: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let h1 = SignHandler::new("app-key-1", TEST_APP_SECRET, dao1).unwrap();
let h2 = SignHandler::new("app-key-2", TEST_APP_SECRET, dao2).unwrap();
let s1 = h1.sign("POST", "/api", 1700000000, "n", "body");
let s2 = h2.sign("POST", "/api", 1700000000, "n", "body");
assert_ne!(s1, s2, "不同 app_key 应通过 HKDF salt 产生不同签名");
}
#[tokio::test]
async fn validate_success() {
let handler = make_handler();
let ts = now_ts();
let sig = handler.sign("POST", "/api/v1/users", ts, "nonce-1", "body-sha256");
let result = handler
.validate("POST", "/api/v1/users", ts, "nonce-1", "body-sha256", &sig)
.await;
assert!(result.is_ok());
}
#[tokio::test]
async fn validate_success_stores_nonce() {
let dao = Arc::new(MockDao::new());
let handler = SignHandler::new("app-001", TEST_APP_SECRET, dao.clone()).unwrap();
let ts = now_ts();
let sig = handler.sign("GET", "/api", ts, "nonce-store", "body");
handler
.validate("GET", "/api", ts, "nonce-store", "body", &sig)
.await
.unwrap();
let key = "garrison:sign:nonce:nonce-store";
let stored = dao.get(key).await.unwrap();
assert!(stored.is_some());
}
#[tokio::test]
async fn validate_signature_mismatch_returns_error() {
let handler = make_handler();
let ts = now_ts();
let result = handler
.validate(
"POST",
"/api",
ts,
"nonce-mismatch",
"body",
"forged-signature",
)
.await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidToken(_)) => {},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn validate_expired_timestamp_returns_error() {
let handler = make_handler();
let old_ts = now_ts() - 600; let sig = handler.sign("POST", "/api", old_ts, "nonce-exp", "body");
let result = handler
.validate("POST", "/api", old_ts, "nonce-exp", "body", &sig)
.await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::ExpiredToken(_)) => {},
other => panic!("期望 ExpiredToken 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn validate_future_timestamp_returns_error() {
let handler = make_handler();
let future_ts = now_ts() + 600;
let sig = handler.sign("POST", "/api", future_ts, "nonce-fut", "body");
let result = handler
.validate("POST", "/api", future_ts, "nonce-fut", "body", &sig)
.await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::ExpiredToken(_)) => {},
other => panic!("期望 ExpiredToken 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn validate_nonce_replay_rejected() {
let handler = make_handler();
let ts = now_ts();
let sig = handler.sign("POST", "/api", ts, "nonce-replay", "body");
let first = handler
.validate("POST", "/api", ts, "nonce-replay", "body", &sig)
.await;
assert!(first.is_ok());
let second = handler
.validate("POST", "/api", ts, "nonce-replay", "body", &sig)
.await;
assert!(second.is_err());
match second.err() {
Some(GarrisonError::InvalidToken(_)) => {},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn validate_method_case_difference_returns_error() {
let handler = make_handler();
let ts = now_ts();
let sig = handler.sign("POST", "/api", ts, "nonce-case", "body");
let result = handler
.validate("post", "/api", ts, "nonce-case", "body", &sig)
.await;
assert!(result.is_err());
}