use super::rate_limiter::{normalize_email, validate_email};
use super::service::generate_code;
use super::*;
use crate::dao::tests::MockDao;
use crate::error::GarrisonError;
use crate::secure::ct_eq::constant_time_eq;
use async_trait::async_trait;
use std::sync::Arc;
#[test]
fn normalize_email_trims_and_lowercases() {
assert_eq!(normalize_email(" Foo@Example.COM "), "foo@example.com");
assert_eq!(normalize_email("USER@DOMAIN.ORG"), "user@domain.org");
assert_eq!(normalize_email(" a@b.c "), "a@b.c");
}
#[test]
fn normalize_email_empty_string() {
assert_eq!(normalize_email(""), "");
assert_eq!(normalize_email(" "), "");
}
#[test]
fn validate_email_valid() {
assert!(validate_email("user@example.com").is_ok());
assert!(validate_email("a@b.c").is_ok());
assert!(validate_email("test+tag@domain.org").is_ok());
}
#[test]
fn validate_email_empty_rejected() {
let err = validate_email("").unwrap_err();
assert!(
matches!(err, crate::error::GarrisonError::InvalidParam(msg) if msg.starts_with("secure-email-empty"))
);
}
#[test]
fn validate_email_colon_rejected() {
let err = validate_email("a:b@c.com").unwrap_err();
assert!(
matches!(err, crate::error::GarrisonError::InvalidParam(msg) if msg.starts_with("secure-email-no-colon"))
);
}
#[test]
fn validate_email_control_char_rejected() {
let err = validate_email("user\x00@example.com").unwrap_err();
assert!(
matches!(err, crate::error::GarrisonError::InvalidParam(msg) if msg.starts_with("secure-email-no-control-char"))
);
}
#[test]
fn validate_email_too_long_rejected() {
let long = format!("{}@b.com", "a".repeat(250));
let err = validate_email(&long).unwrap_err();
assert!(
matches!(err, crate::error::GarrisonError::InvalidParam(msg) if msg.starts_with("secure-email-invalid-format"))
);
}
#[test]
fn validate_email_no_at_rejected() {
let err = validate_email("userexample.com").unwrap_err();
assert!(
matches!(err, crate::error::GarrisonError::InvalidParam(msg) if msg.starts_with("secure-email-invalid-format"))
);
}
#[test]
fn generate_code_returns_six_digits() {
for _ in 0..100 {
let code = generate_code().unwrap();
assert_eq!(code.len(), 6);
assert!(code.chars().all(|c| c.is_ascii_digit()));
assert_ne!(code, "000000");
let num: u32 = code.parse().unwrap();
assert!((100000..1000000).contains(&num));
}
}
#[test]
fn code_ct_eq_equal_strings() {
use crate::secure::ct_eq::constant_time_eq;
assert!(constant_time_eq(b"123456", b"123456"));
}
#[test]
fn code_ct_eq_different_strings() {
use crate::secure::ct_eq::constant_time_eq;
assert!(!constant_time_eq(b"123456", b"654321"));
assert!(!constant_time_eq(b"123456", b"123457"));
}
#[test]
fn constant_time_eq_equal_strings() {
assert!(constant_time_eq(b"123456", b"123456"));
assert!(constant_time_eq(b"", b""));
}
#[test]
fn constant_time_eq_different_strings() {
assert!(!constant_time_eq(b"123456", b"654321"));
assert!(!constant_time_eq(b"123456", b"123457"));
}
#[test]
fn code_ct_eq_different_lengths() {
use crate::secure::ct_eq::constant_time_eq;
assert!(!constant_time_eq(b"123456", b"12345"));
assert!(!constant_time_eq(b"12", b"123456"));
}
#[test]
fn constant_time_eq_different_lengths() {
assert!(!constant_time_eq(b"123456", b"12345"));
assert!(!constant_time_eq(b"12", b"123456"));
assert!(!constant_time_eq(b"", b"123456"));
assert!(!constant_time_eq(b"123456", b""));
}
#[tokio::test]
async fn wrong_length_code_counts_as_failed_attempt() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let service = make_service_with(dao.clone(), 3, 3);
service.send_code("user6@example.com").await.unwrap();
let oversized = "1".repeat(1024 * 1024);
let result = service.verify_code("user6@example.com", &oversized).await;
assert!(
matches!(result, Err(GarrisonError::InvalidParam(ref m)) if m.starts_with(service::ERR_EMAIL_CODE_WRONG)),
"超长验证码应按错误验证码拒绝,实际: {:?}",
result
);
let result = service.verify_code("user6@example.com", "12345").await;
assert!(matches!(result, Err(GarrisonError::InvalidParam(_))));
let attempts = dao.get("email:attempts:user6@example.com").await.unwrap();
assert_eq!(
attempts,
Some("2".to_string()),
"长度不符的输入应计入失败尝试"
);
}
#[cfg(feature = "email-verification-smtp")]
#[test]
fn smtp_config_defaults() {
let config = super::smtp::SmtpConfig::default();
assert_eq!(config.port, 587);
assert_eq!(config.from_name, "Garrison");
assert!(config.use_tls);
assert!(config.host.is_empty());
assert!(config.username.is_empty());
}
struct NoopEmailSender;
#[async_trait]
impl EmailSender for NoopEmailSender {
async fn send(&self, _to: &str, _subject: &str, _body: &str) -> GarrisonResult<()> {
Ok(())
}
}
struct CapturingEmailSender {
mail: parking_lot::Mutex<Option<(String, String, String)>>,
}
#[async_trait]
impl EmailSender for CapturingEmailSender {
async fn send(&self, to: &str, subject: &str, body: &str) -> GarrisonResult<()> {
*self.mail.lock() = Some((to.to_string(), subject.to_string(), body.to_string()));
Ok(())
}
}
struct FailingEmailSender;
#[async_trait]
impl EmailSender for FailingEmailSender {
async fn send(&self, _to: &str, _subject: &str, _body: &str) -> GarrisonResult<()> {
Err(GarrisonError::Network(
"email-smtp-send-failed::mock-network-down".to_string(),
))
}
}
fn make_service() -> EmailVerificationService {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
make_service_with(dao, 3, 100)
}
fn make_service_with(
dao: Arc<dyn GarrisonDao>,
max_attempts: u32,
unverified_threshold: u32,
) -> EmailVerificationService {
let rate_limiter = EmailRateLimiter::new(dao.clone(), 5, 10);
EmailVerificationService::new(
rate_limiter,
Arc::new(NoopEmailSender),
dao,
max_attempts,
unverified_threshold,
600,
)
}
#[tokio::test]
async fn hourly_limit_allows_first_5() {
let service = make_service();
for i in 0..5 {
let result = service.send_code("user@example.com").await;
assert!(
result.is_ok(),
"第 {} 次发送应成功,实际: {:?}",
i + 1,
result
);
}
}
#[tokio::test]
async fn hourly_limit_blocks_6th() {
let service = make_service();
for _ in 0..5 {
service.send_code("user1@example.com").await.unwrap();
}
let result = service.send_code("user1@example.com").await;
assert!(
matches!(result, Err(GarrisonError::EmailRateLimitExceeded { ref window }) if window == "hourly"),
"第 6 次应被小时限速拦截,实际: {:?}",
result
);
}
#[tokio::test]
async fn daily_limit_blocks_11th() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let service = EmailVerificationService::new(
EmailRateLimiter::new(dao.clone(), 100, 10),
Arc::new(NoopEmailSender),
dao.clone(),
3,
100,
600,
);
for _ in 0..10 {
service.send_code("user2@example.com").await.unwrap();
}
let result = service.send_code("user2@example.com").await;
assert!(
matches!(result, Err(GarrisonError::EmailRateLimitExceeded { ref window }) if window == "daily"),
"第 11 次应被天限速拦截,实际: {:?}",
result
);
}
#[tokio::test]
async fn verify_max_attempts_after_3_failures() {
let service = make_service_with(Arc::new(MockDao::new()), 3, 100);
service.send_code("user3@example.com").await.unwrap();
for _ in 0..3 {
let r = service.verify_code("user3@example.com", "000000").await;
assert!(
matches!(r, Err(GarrisonError::InvalidParam(_))),
"前 3 次错误应返回 InvalidParam"
);
}
let result = service.verify_code("user3@example.com", "000000").await;
assert!(
matches!(result, Err(GarrisonError::EmailVerifyMaxAttempts)),
"第 4 次应返回 EmailVerifyMaxAttempts,实际: {:?}",
result
);
}
#[tokio::test]
async fn correct_code_verifies_and_clears_state() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let sender = Arc::new(CapturingEmailSender {
mail: parking_lot::Mutex::new(None),
});
let service = EmailVerificationService::new(
EmailRateLimiter::new(dao.clone(), 5, 10),
sender.clone(),
dao.clone(),
3,
3,
600,
);
service.send_code("User@Example.COM").await.unwrap();
let (to, subject, body) = sender.mail.lock().clone().unwrap();
assert_eq!(to, "user@example.com", "收件人应为规范化(小写)地址");
assert!(!subject.is_empty(), "邮件主题不应为空");
let code = dao
.get("email:code:user@example.com")
.await
.unwrap()
.unwrap();
assert!(body.contains(&code), "邮件正文应包含验证码 {}", code);
let result = service.verify_code("user@example.com", &code).await;
assert!(result.is_ok(), "正确验证码应验证通过");
assert!(
dao.get("email:code:user@example.com")
.await
.unwrap()
.is_none(),
"验证后验证码应被删除"
);
assert!(
dao.get("email:unverified:user@example.com")
.await
.unwrap()
.is_none(),
"验证后未验证计数应被清零"
);
assert!(
dao.get("email:attempts:user@example.com")
.await
.unwrap()
.is_none(),
"验证后尝试计数应被清零"
);
}
#[tokio::test]
async fn wrong_code_increments_attempts() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let service = make_service_with(dao.clone(), 3, 3);
service.send_code("user4@example.com").await.unwrap();
service
.verify_code("user4@example.com", "wrong1")
.await
.unwrap_err();
let attempts = dao.get("email:attempts:user4@example.com").await.unwrap();
assert_eq!(attempts, Some("1".to_string()));
service
.verify_code("user4@example.com", "wrong2")
.await
.unwrap_err();
let attempts = dao.get("email:attempts:user4@example.com").await.unwrap();
assert_eq!(attempts, Some("2".to_string()));
}
#[tokio::test]
async fn missing_code_returns_not_found() {
let service = make_service();
let result = service.verify_code("user5@example.com", "123456").await;
assert!(
matches!(result, Err(GarrisonError::EmailCodeNotFound)),
"不存在的验证码应返回 EmailCodeNotFound,实际: {:?}",
result
);
}
#[tokio::test]
async fn rate_key_format_hour() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let service = make_service_with(dao.clone(), 3, 3);
service.send_code("user6@example.com").await.unwrap();
let value = dao.get("quota:hour:email:user6@example.com").await.unwrap();
assert!(
value.is_some(),
"应存在 quota:hour:email:{{addr}} 格式的限速账本 key"
);
}
#[tokio::test]
async fn code_key_format_is_normalized() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let service = make_service_with(dao.clone(), 3, 3);
service.send_code("User7@Example.COM").await.unwrap();
let stored = dao.get("email:code:user7@example.com").await.unwrap();
assert!(stored.is_some(), "应存在小写规范化 email:code:{{addr}} key");
}
#[tokio::test(flavor = "multi_thread")]
async fn concurrent_send_does_not_exceed_limit() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let rate_limiter = EmailRateLimiter::new(dao.clone(), 5, 10);
let service = Arc::new(EmailVerificationService::new(
rate_limiter,
Arc::new(NoopEmailSender),
dao.clone(),
3,
100,
600,
));
let mut handles = Vec::new();
for _ in 0..10 {
let s = service.clone();
handles.push(tokio::spawn(async move {
s.send_code("user8@example.com").await
}));
}
let mut success = 0;
let mut rate_limited = 0;
for handle in handles {
match handle.await.unwrap() {
Ok(()) => success += 1,
Err(GarrisonError::EmailRateLimitExceeded { .. }) => rate_limited += 1,
Err(e) => panic!("不应返回其他错误: {:?}", e),
}
}
assert_eq!(success, 5, "仅 5 次发送应成功(小时限速 5/h)");
assert_eq!(rate_limited, 5, "其余 5 次应被限速");
}
#[tokio::test]
async fn unverified_threshold_recycles_channel() {
let service = make_service_with(Arc::new(MockDao::new()), 3, 3);
for i in 0..3 {
let r = service.send_code("user9@example.com").await;
assert!(r.is_ok(), "第 {} 次发送应成功", i + 1);
}
let result = service.send_code("user9@example.com").await;
assert!(
matches!(result, Err(GarrisonError::EmailChannelRecycled)),
"第 4 次发送应触发 EmailChannelRecycled,实际: {:?}",
result
);
let result = service.send_code("user9@example.com").await;
assert!(
matches!(result, Err(GarrisonError::EmailChannelRecycled)),
"通道回收后应继续返回 EmailChannelRecycled"
);
}
#[tokio::test]
async fn send_failure_rolls_back_all_state() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let service = EmailVerificationService::new(
EmailRateLimiter::new(dao.clone(), 5, 10),
Arc::new(FailingEmailSender),
dao.clone(),
3,
100,
600,
);
let result = service.send_code("user10@example.com").await;
assert!(
matches!(&result, Err(GarrisonError::Network(msg)) if msg.contains("email-smtp-send-failed")),
"发送失败应透传 Network 错误,实际: {:?}",
result
);
assert!(
dao.get("email:code:user10@example.com")
.await
.unwrap()
.is_none(),
"发送失败后验证码应被删除"
);
assert!(
dao.get("quota:hour:email:user10@example.com")
.await
.unwrap()
.is_none(),
"发送失败后小时限速账本应回滚删除"
);
assert!(
dao.get("quota:day:email:user10@example.com")
.await
.unwrap()
.is_none(),
"发送失败后天限速账本应回滚删除"
);
assert!(
dao.get("email:unverified:user10@example.com")
.await
.unwrap()
.is_none(),
"发送失败后未验证计数应回滚删除"
);
}
#[tokio::test]
async fn case_variants_share_rate_budget() {
let service = make_service();
let variants = [
"User@Example.COM",
"USER@example.com",
"user@example.com",
"User@example.com",
"USER@EXAMPLE.COM",
];
for (i, v) in variants.iter().enumerate() {
let r = service.send_code(v).await;
assert!(r.is_ok(), "变体 {} 第 {} 次发送应成功: {:?}", v, i + 1, r);
}
let result = service.send_code("user@Example.com").await;
assert!(
matches!(result, Err(GarrisonError::EmailRateLimitExceeded { ref window }) if window == "hourly"),
"大小写变体应共享限速预算:第 6 次应被拦截,实际: {:?}",
result
);
}
#[test]
fn validate_email_boundary_254() {
let ok = format!("{}@b.com", "a".repeat(248));
assert_eq!(ok.len(), 254);
assert!(validate_email(&ok).is_ok(), "恰好 254 字符应放行");
let too_long = format!("{}@b.com", "a".repeat(249));
assert_eq!(too_long.len(), 255);
assert!(validate_email(&too_long).is_err(), "255 字符应拒绝");
}
#[tokio::test]
async fn rollback_invalid_email_returns_invalid_param() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let limiter = EmailRateLimiter::new(dao, 100, 100);
let result = limiter.rollback("a:b@c.com").await;
assert!(
matches!(&result, Err(GarrisonError::InvalidParam(msg)) if msg.starts_with("secure-email-no-colon")),
"回滚含冒号邮箱应返回 InvalidParam(secure-email-no-colon),实际: {:?}",
result
);
}
#[tokio::test]
async fn check_and_increment_rejects_blank_email() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let limiter = EmailRateLimiter::new(dao, 100, 100);
let result = limiter.check_and_increment(" ").await;
assert!(
matches!(&result, Err(GarrisonError::InvalidParam(msg)) if msg.starts_with("secure-email-empty")),
"空白邮箱应返回 InvalidParam(secure-email-empty),实际: {:?}",
result
);
}