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-for-unit-tests-01").expect("secret 非空构造应成功")
}
#[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-for-unit-tests-01")
.expect("secret 非空构造应成功");
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!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"第二次校验应返回 InvalidToken,实际: {:?}",
result
);
}
#[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_eq!(first.unwrap(), "1001", "第一次校验应返回 login_id");
assert!(
matches!(second, Err(GarrisonError::InvalidToken(_))),
"第二次校验应返回 InvalidToken,实际: {:?}",
second
);
}
#[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_eq!(result.unwrap(), (), "销毁存在的票据应返回 Ok(())");
let validate_result = client.validate_ticket(&ticket, 2001).await;
assert!(
matches!(validate_result, Err(GarrisonError::InvalidToken(_))),
"已销毁票据 validate 应返回 InvalidToken,实际: {:?}",
validate_result
);
}
#[tokio::test]
async fn destroy_ticket_nonexistent_returns_ok() {
let client = make_client();
let result = client.destroy_ticket("nonexistent-ticket").await;
assert_eq!(result.unwrap(), (), "销毁不存在的票据应返回 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-for-unit-tests-01")
.expect("secret 非空构造应成功")
.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-0123456789abcdef-32bytes!")
.expect("secret 非空构造应成功");
let validator =
SsoClient::new(dao, "secret-b-0123456789abcdef-32bytes!").expect("secret 非空构造应成功");
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]
fn new_rejects_empty_secret() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let result = SsoClient::new(dao, "");
match result {
Err(GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("sso-client-secret-empty"),
"错误消息应含 sso-client-secret-empty 前缀,实际: {}",
msg
);
},
Err(other) => panic!("期望 InvalidParam,实际: {:?}", other),
Ok(_) => panic!("空 secret 不应构造成功"),
}
}
#[test]
fn new_rejects_short_secret() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let result = SsoClient::new(dao, "a".repeat(31));
match result {
Err(GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("sso-client-secret-too-short"),
"错误消息应含 sso-client-secret-too-short 前缀,实际: {}",
msg
);
},
Err(other) => panic!("期望 InvalidParam,实际: {:?}", other),
Ok(_) => panic!("31 字节 secret 不应构造成功"),
}
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
assert!(
SsoClient::new(dao, "a".repeat(32)).is_ok(),
"32 字节 secret 应构造成功"
);
}
#[tokio::test]
async fn validate_ticket_client_id_mismatch_message_does_not_leak_ids() {
let client = make_client();
let ticket = client.issue_ticket("1001", 2001).await.unwrap();
let result = client.validate_ticket(&ticket, 9999).await;
match result {
Err(GarrisonError::InvalidToken(msg)) => {
assert!(
msg.contains("sso-ticket-client-id-mismatch"),
"错误消息应含固定前缀,实际: {}",
msg
);
assert!(
!msg.contains("2001") && !msg.contains("9999"),
"错误消息不得回显 client_id,实际: {}",
msg
);
},
other => panic!("期望 InvalidToken,实际: {:?}", other),
}
}
mod saml_provider_tests {
use super::*;
use crate::protocol::sso::saml::{DefaultSamlProvider, SamlProvider};
fn saml_xml(destination: &str, audience: &str) -> String {
let future = chrono::Utc::now().timestamp() + 3600;
let future_str = chrono::DateTime::from_timestamp(future, 0)
.unwrap()
.to_rfc3339();
format!(
r#"<?xml version="1.0" encoding="UTF-8"?>
<samlp:Response xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"
xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion"
Destination="{destination}">
<saml:Issuer>https://idp.example.com</saml:Issuer>
<samlp:Status>
<samlp:StatusCode Value="urn:oasis:names:tc:SAML:2.0:status:Success"/>
</samlp:Status>
<saml:Assertion ID="assertion-123">
<saml:Issuer>https://idp.example.com</saml:Issuer>
<saml:Subject>
<saml:NameID>user@example.com</saml:NameID>
<saml:SubjectConfirmation>
<saml:SubjectConfirmationData NotOnOrAfter="{future_str}"></saml:SubjectConfirmationData>
</saml:SubjectConfirmation>
</saml:Subject>
<saml:Conditions NotBefore="2020-01-01T00:00:00Z">
<saml:AudienceRestriction>
<saml:Audience>{audience}</saml:Audience>
</saml:AudienceRestriction>
</saml:Conditions>
</saml:Assertion>
<saml:Extensions><saml:VendorSpecific x="1"/></saml:Extensions>
</samlp:Response>"#
)
}
#[test]
fn default_impl_constructs() {
let _provider = DefaultSamlProvider::default();
}
#[tokio::test]
async fn destination_mismatch_is_rejected_when_expected_configured() {
let provider = DefaultSamlProvider::new()
.unwrap()
.with_expected_destination("https://sp.example.com/acs".to_string());
let err = provider
.parse_response(&saml_xml(
"https://evil.example.com/acs",
"https://sp.example.com",
))
.await
.unwrap_err();
assert!(
matches!(&err, GarrisonError::InvalidParam(m) if m.contains("sso-saml-destination-mismatch")),
"Destination 不匹配应报 sso-saml-destination-mismatch,实际: {err:?}"
);
}
#[tokio::test]
async fn destination_match_passes_when_expected_configured() {
let provider = DefaultSamlProvider::new()
.unwrap()
.with_expected_destination("https://sp.example.com/acs".to_string());
let response = provider
.parse_response(&saml_xml(
"https://sp.example.com/acs",
"https://sp.example.com",
))
.await
.unwrap();
assert_eq!(response.destination, "https://sp.example.com/acs");
}
#[tokio::test]
async fn audience_mismatch_is_rejected_when_expected_configured() {
let provider = DefaultSamlProvider::new()
.unwrap()
.with_expected_audience("https://sp.example.com".to_string());
let err = provider
.parse_response(&saml_xml(
"https://sp.example.com/acs",
"https://other-sp.example.com",
))
.await
.unwrap_err();
assert!(
matches!(&err, GarrisonError::InvalidParam(m) if m.contains("sso-saml-audience-mismatch")),
"Audience 不匹配应报 sso-saml-audience-mismatch,实际: {err:?}"
);
}
#[tokio::test]
async fn audience_match_passes_when_expected_configured() {
let provider = DefaultSamlProvider::new()
.unwrap()
.with_expected_audience("https://sp.example.com".to_string());
let response = provider
.parse_response(&saml_xml(
"https://sp.example.com/acs",
"https://sp.example.com",
))
.await
.unwrap();
assert!(
response.assertion.is_none(),
"无签名校验实现时 Assertion 剥离"
);
}
#[tokio::test]
async fn duplicate_attribute_names_are_all_collected() {
let future = chrono::Utc::now().timestamp() + 3600;
let future_str = chrono::DateTime::from_timestamp(future, 0)
.unwrap()
.to_rfc3339();
let xml = format!(
r#"<?xml version="1.0" encoding="UTF-8"?>
<samlp:Response xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"
xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion"
Destination="https://sp.example.com/acs">
<saml:Issuer>https://idp.example.com</saml:Issuer>
<samlp:Status>
<samlp:StatusCode Value="urn:oasis:names:tc:SAML:2.0:status:Success"/>
</samlp:Status>
<saml:Assertion ID="a1">
<saml:Issuer>https://idp.example.com</saml:Issuer>
<saml:Subject>
<saml:NameID>user@example.com</saml:NameID>
<saml:SubjectConfirmation>
<saml:SubjectConfirmationData NotOnOrAfter="{future_str}"></saml:SubjectConfirmationData>
</saml:SubjectConfirmation>
</saml:Subject>
<saml:AttributeStatement>
<saml:Attribute Name="role">
<saml:AttributeValue>admin</saml:AttributeValue>
<saml:AttributeValue>auditor</saml:AttributeValue>
</saml:Attribute>
</saml:AttributeStatement>
</saml:Assertion>
</samlp:Response>"#
);
let provider = DefaultSamlProvider::new().unwrap();
let response = provider.parse_response(&xml).await.unwrap();
assert!(
response.assertion.is_none(),
"无签名校验时 Assertion 剥离,属性解析分支仍应执行"
);
}
}