use super::service::constant_time_eq;
use super::*;
use crate::dao::tests::MockDao;
use crate::error::GarrisonError;
use std::sync::Arc;
fn make_service() -> SmsVerificationService {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let rate_limiter = SmsRateLimiter::new(dao.clone(), 5, 10);
let sender: Arc<dyn SmsSender> = Arc::new(NoopSmsSender);
SmsVerificationService::new(rate_limiter, sender, dao, 3, 100)
}
#[tokio::test]
async fn hourly_limit_allows_first_5() {
let service = make_service();
for i in 0..5 {
let result = service.send_code("13800138000").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("13800138001").await.unwrap();
}
let result = service.send_code("13800138001").await;
assert!(
matches!(result, Err(GarrisonError::SmsRateLimitExceeded { 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 = SmsVerificationService::new(
SmsRateLimiter::new(dao.clone(), 100, 10),
Arc::new(NoopSmsSender),
dao.clone(),
3,
100,
);
for _ in 0..10 {
service.send_code("13800138002").await.unwrap();
}
let result = service.send_code("13800138002").await;
assert!(
matches!(result, Err(GarrisonError::SmsRateLimitExceeded { ref window }) if window == "daily"),
"第 11 次应被天限速拦截,实际: {:?}",
result
);
}
#[tokio::test]
async fn verify_max_attempts_after_3_failures() {
let service = make_service();
service.send_code("13800138003").await.unwrap();
for _ in 0..3 {
let r = service.verify_code("13800138003", "000000").await;
assert!(
matches!(r, Err(GarrisonError::InvalidParam(_))),
"前 3 次错误应返回 InvalidParam"
);
}
let result = service.verify_code("13800138003", "000000").await;
assert!(
matches!(result, Err(GarrisonError::SmsVerifyMaxAttempts)),
"第 4 次应返回 SmsVerifyMaxAttempts,实际: {:?}",
result
);
}
#[tokio::test]
async fn correct_code_verifies_and_deletes() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
struct CapturingSender {
code: parking_lot::Mutex<Option<String>>,
}
#[async_trait]
impl SmsSender for CapturingSender {
async fn send(&self, _phone: &str, code: &str) -> GarrisonResult<()> {
*self.code.lock() = Some(code.to_string());
Ok(())
}
}
let sender = Arc::new(CapturingSender {
code: parking_lot::Mutex::new(None),
});
let service = SmsVerificationService::new(
SmsRateLimiter::new(dao.clone(), 5, 10),
sender.clone(),
dao.clone(),
3,
3,
);
service.send_code("13800138004").await.unwrap();
let code = sender.code.lock().as_ref().cloned().unwrap();
let result = service.verify_code("13800138004", &code).await;
assert!(result.is_ok(), "正确验证码应验证通过");
let stored = dao.get("sms:code:13800138004").await.unwrap();
assert!(stored.is_none(), "验证后验证码应被删除");
}
#[tokio::test]
async fn wrong_code_increments_attempts() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let service = SmsVerificationService::new(
SmsRateLimiter::new(dao.clone(), 5, 10),
Arc::new(NoopSmsSender),
dao.clone(),
3,
3,
);
service.send_code("13800138005").await.unwrap();
service
.verify_code("13800138005", "wrong")
.await
.unwrap_err();
let attempts = dao.get("sms:attempts:13800138005").await.unwrap();
assert_eq!(attempts, Some("1".to_string()));
service
.verify_code("13800138005", "wrong")
.await
.unwrap_err();
let attempts = dao.get("sms:attempts:13800138005").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("13800138006", "123456").await;
assert!(
matches!(result, Err(GarrisonError::SmsCodeNotFound)),
"不存在的验证码应返回 SmsCodeNotFound,实际: {:?}",
result
);
}
#[tokio::test]
async fn rate_key_format_hour() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let service = SmsVerificationService::new(
SmsRateLimiter::new(dao.clone(), 5, 10),
Arc::new(NoopSmsSender),
dao.clone(),
3,
3,
);
service.send_code("13800138007").await.unwrap();
let keys = dao.keys("sms:rate:13800138007:hour:*").await.unwrap();
assert!(
!keys.is_empty(),
"应存在 sms:rate:{{phone}}:hour:{{bucket}} 格式的 key"
);
}
#[tokio::test]
async fn code_key_format() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let service = SmsVerificationService::new(
SmsRateLimiter::new(dao.clone(), 5, 10),
Arc::new(NoopSmsSender),
dao.clone(),
3,
3,
);
service.send_code("13800138008").await.unwrap();
let stored = dao.get("sms:code:13800138008").await.unwrap();
assert!(stored.is_some(), "应存在 sms:code:{{phone}} 格式的 key");
}
#[tokio::test(flavor = "multi_thread")]
async fn concurrent_send_does_not_exceed_limit() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let service = Arc::new(SmsVerificationService::new(
SmsRateLimiter::new(dao.clone(), 5, 10),
Arc::new(NoopSmsSender),
dao.clone(),
3,
100,
));
let mut handles = Vec::new();
for _ in 0..10 {
let s = service.clone();
handles.push(tokio::spawn(
async move { s.send_code("13800138009").await },
));
}
let mut success = 0;
let mut rate_limited = 0;
for handle in handles {
match handle.await.unwrap() {
Ok(()) => success += 1,
Err(GarrisonError::SmsRateLimitExceeded { .. }) => rate_limited += 1,
Err(e) => panic!("不应返回其他错误: {:?}", e),
}
}
assert_eq!(success, 5, "仅 5 次发送应成功(小时限速 5/h)");
assert_eq!(rate_limited, 5, "其余 5 次应被限速");
}
#[tokio::test]
async fn noop_sms_sender_does_not_error() {
let sender = NoopSmsSender;
let result = sender.send("13800138010", "123456").await;
assert!(result.is_ok(), "NoopSmsSender 不应报错");
}
#[tokio::test]
async fn unverified_threshold_recycles_channel() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let service = SmsVerificationService::new(
SmsRateLimiter::new(dao.clone(), 100, 100),
Arc::new(NoopSmsSender),
dao.clone(),
3,
3,
);
for i in 0..3 {
let r = service.send_code("13800138011").await;
assert!(r.is_ok(), "第 {} 次发送应成功", i + 1);
}
let result = service.send_code("13800138011").await;
assert!(
matches!(result, Err(GarrisonError::SmsChannelRecycled)),
"第 4 次发送应触发 SmsChannelRecycled,实际: {:?}",
result
);
let result = service.send_code("13800138011").await;
assert!(
matches!(result, Err(GarrisonError::SmsChannelRecycled)),
"通道回收后应继续返回 SmsChannelRecycled"
);
}
#[test]
fn constant_time_eq_same_string_returns_true() {
assert!(constant_time_eq("123456", "123456"));
assert!(constant_time_eq("", ""));
assert!(constant_time_eq("abcdef", "abcdef"));
}
#[test]
fn constant_time_eq_different_string_returns_false() {
assert!(!constant_time_eq("123456", "000000"));
assert!(!constant_time_eq("123456", "123457"));
assert!(!constant_time_eq("abcdef", "abcdeF"));
}
#[test]
fn constant_time_eq_different_length_returns_false() {
assert!(!constant_time_eq("12345", "123456"));
assert!(!constant_time_eq("1234567", "123456"));
assert!(!constant_time_eq("", "123456"));
}
#[test]
fn constant_time_eq_first_byte_diff_returns_false() {
assert!(!constant_time_eq("023456", "123456"));
}
#[test]
fn constant_time_eq_last_byte_diff_returns_false() {
assert!(!constant_time_eq("123450", "123456"));
}
#[test]
fn generate_code_returns_6_char_string() {
let code = super::service::generate_code().expect("生成验证码不应失败");
assert_eq!(code.len(), 6, "验证码必须是 6 位字符: {}", code);
}
#[test]
fn generate_code_never_returns_000000() {
for _ in 0..10000 {
let code = super::service::generate_code().expect("生成验证码不应失败");
assert_ne!(code, "000000", "验证码不应为 000000(弱验证码)");
assert_eq!(code.len(), 6, "验证码必须是 6 位字符: {}", code);
}
}
#[test]
fn generate_code_always_in_6_digit_range() {
for _ in 0..10000 {
let code = super::service::generate_code().expect("生成验证码不应失败");
let parsed: u32 = code
.parse()
.unwrap_or_else(|_| panic!("验证码必须是纯数字: {}", code));
assert!(
(100000..1000000).contains(&parsed),
"验证码必须在 [100000, 999999] 范围内: {}",
code
);
assert_ne!(
code.chars().next().unwrap(),
'0',
"验证码首位不应为 0: {}",
code
);
}
}