use super::mock::MockDao;
use super::*;
use crate::error::GarrisonError;
fn make_client() -> SsoClient {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
SsoClient::new(dao, "test-sso-secret-key")
}
#[test]
fn new_creates_client_with_dao() {
let _client = make_client();
}
#[tokio::test]
async fn issue_ticket_returns_signed_format() {
let client = make_client();
let ticket = client.issue_ticket("1001", 2001).await.unwrap();
let (random_part, sig) = ticket.split_once('.').expect("ticket 应包含 '.' 分隔符");
assert_eq!(random_part.len(), 64, "随机部分应为 64 字符 hex");
assert!(
random_part.chars().all(|c| c.is_ascii_hexdigit()),
"随机部分应全为 hex 字符"
);
assert!(!sig.is_empty(), "签名部分不应为空");
}
#[tokio::test]
async fn issue_ticket_generates_unique_tickets() {
let client = make_client();
let t1 = client.issue_ticket("1001", 2001).await.unwrap();
let t2 = client.issue_ticket("1001", 2001).await.unwrap();
assert_ne!(t1, t2);
}
#[tokio::test]
async fn issue_ticket_same_login_different_clients() {
let client = make_client();
let t1 = client.issue_ticket("1001", 2001).await.unwrap();
let t2 = client.issue_ticket("1001", 2002).await.unwrap();
assert_ne!(t1, t2);
}
#[tokio::test]
async fn issue_ticket_uses_correct_key_prefix() {
let dao = Arc::new(MockDao::new());
let client = SsoClient::new(dao.clone(), "test-sso-secret-key");
let ticket = client.issue_ticket("1001", 2001).await.unwrap();
let key = format!("garrison:sso:ticket:{}", ticket);
let value = dao.get(&key).await.unwrap();
assert!(value.is_some());
let data: SsoTicketData = serde_json::from_str(&value.unwrap()).unwrap();
assert_eq!(data.login_id, "1001");
assert_eq!(data.client_id, 2001);
}
#[tokio::test]
async fn validate_ticket_success_returns_login_id() {
let client = make_client();
let ticket = client.issue_ticket("1001", 2001).await.unwrap();
let login_id = client.validate_ticket(&ticket, 2001).await.unwrap();
assert_eq!(login_id, "1001");
}
#[tokio::test]
async fn validate_ticket_deletes_after_success() {
let client = make_client();
let ticket = client.issue_ticket("1001", 2001).await.unwrap();
let _ = client.validate_ticket(&ticket, 2001).await.unwrap();
let result = client.validate_ticket(&ticket, 2001).await;
assert!(result.is_err());
}
#[tokio::test]
async fn validate_ticket_client_id_mismatch_returns_error() {
let client = make_client();
let ticket = client.issue_ticket("1001", 2001).await.unwrap();
let result = client.validate_ticket(&ticket, 9999).await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidToken(_)) => {},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn validate_ticket_nonexistent_returns_error() {
let client = make_client();
let result = client.validate_ticket("nonexistent-ticket", 2001).await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidToken(_)) => {},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn validate_ticket_one_time_use_second_fails() {
let client = make_client();
let ticket = client.issue_ticket("1001", 2001).await.unwrap();
let first = client.validate_ticket(&ticket, 2001).await;
let second = client.validate_ticket(&ticket, 2001).await;
assert!(first.is_ok());
assert!(second.is_err());
}
#[tokio::test]
async fn destroy_ticket_existing() {
let client = make_client();
let ticket = client.issue_ticket("1001", 2001).await.unwrap();
let result = client.destroy_ticket(&ticket).await;
assert!(result.is_ok());
let validate_result = client.validate_ticket(&ticket, 2001).await;
assert!(validate_result.is_err());
}
#[tokio::test]
async fn destroy_ticket_nonexistent_returns_ok() {
let client = make_client();
let result = client.destroy_ticket("nonexistent-ticket").await;
assert!(result.is_ok());
}
#[test]
fn with_ticket_ttl_sets_ttl() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let client = SsoClient::new(dao, "test-sso-secret-key").with_ticket_ttl(120);
assert_eq!(client.ticket_ttl_seconds, 120);
}
#[tokio::test]
async fn issue_ticket_accepts_login_id_numeric() {
let client = make_client();
let ticket = client.issue_ticket("1001".to_string(), 2001).await.unwrap();
let login_id = client.validate_ticket(&ticket, 2001).await.unwrap();
assert_eq!(login_id, "1001");
}
#[tokio::test(flavor = "multi_thread")]
async fn validate_ticket_concurrent_only_one_succeeds() {
let client = Arc::new(make_client());
let ticket = client.issue_ticket("1001", 2001).await.unwrap();
let mut handles = Vec::new();
for _ in 0..10 {
let c = client.clone();
let t = ticket.clone();
handles.push(tokio::spawn(
async move { c.validate_ticket(&t, 2001).await },
));
}
let mut success = 0;
let mut invalid_token = 0;
for handle in handles {
match handle.await.unwrap() {
Ok(login_id) => {
assert_eq!(login_id, "1001");
success += 1;
},
Err(GarrisonError::InvalidToken(_)) => invalid_token += 1,
Err(e) => panic!("期望 InvalidToken 或 Ok,实际: {:?}", e),
}
}
assert_eq!(success, 1, "并发消费同一 ticket 仅一个成功");
assert_eq!(invalid_token, 9, "其他 9 个应返回 InvalidToken");
}
#[tokio::test]
async fn validate_ticket_rejects_unsigned_ticket() {
let client = make_client();
let fake_ticket = "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789";
let result = client.validate_ticket(fake_ticket, 2001).await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(ref msg)) if msg.contains("sso-ticket-format-no-sig")),
"无签名的 ticket 应被拒绝,实际: {:?}",
result
);
}
#[tokio::test]
async fn validate_ticket_rejects_tampered_signature() {
let client = make_client();
let ticket = client.issue_ticket("1001", 2001).await.unwrap();
let tampered_ticket = format!("{}X", ticket);
let result = client.validate_ticket(&tampered_ticket, 2001).await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(ref msg)) if msg.contains("sso-ticket-sig-verify")),
"篡改签名的 ticket 应被拒绝,实际: {:?}",
result
);
}
#[tokio::test]
async fn validate_ticket_rejects_different_secret() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let issuer = SsoClient::new(dao.clone(), "secret-a");
let validator = SsoClient::new(dao, "secret-b");
let ticket = issuer.issue_ticket("1001", 2001).await.unwrap();
let result = validator.validate_ticket(&ticket, 2001).await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(ref msg)) if msg.contains("sso-ticket-sig-verify")),
"不同 secret 签发的 ticket 应被拒绝,实际: {:?}",
result
);
}
#[test]
#[should_panic(expected = "SSO secret 不能为空")]
fn new_rejects_empty_secret() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let _client = SsoClient::new(dao, "");
}