use super::*;
use crate::dao::tests::MockDao;
use crate::error::GarrisonError;
use crate::secure::ct_eq::constant_time_eq;
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 value = dao.get("quota:hour:sms:13800138007").await.unwrap();
assert!(
value.is_some(),
"应存在 quota:hour:sms:{{phone}} 格式的限速账本 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(b"123456", b"123456"));
assert!(constant_time_eq(b"", b""));
assert!(constant_time_eq(b"abcdef", b"abcdef"));
}
#[test]
fn constant_time_eq_different_string_returns_false() {
assert!(!constant_time_eq(b"123456", b"000000"));
assert!(!constant_time_eq(b"123456", b"123457"));
assert!(!constant_time_eq(b"abcdef", b"abcdeF"));
}
#[test]
fn constant_time_eq_different_length_returns_false() {
assert!(!constant_time_eq(b"12345", b"123456"));
assert!(!constant_time_eq(b"1234567", b"123456"));
assert!(!constant_time_eq(b"", b"123456"));
assert!(!constant_time_eq(b"123456", b""));
}
#[test]
fn constant_time_eq_first_byte_diff_returns_false() {
assert!(!constant_time_eq(b"023456", b"123456"));
}
#[test]
fn constant_time_eq_last_byte_diff_returns_false() {
assert!(!constant_time_eq(b"123450", b"123456"));
}
#[tokio::test]
async fn wrong_length_code_counts_as_failed_attempt() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let rate_limiter = SmsRateLimiter::new(dao.clone(), 100, 100);
let sender: Arc<dyn SmsSender> = Arc::new(NoopSmsSender);
let service = SmsVerificationService::new(rate_limiter, sender, dao.clone(), 3, 100);
service.send_code("13800138020").await.unwrap();
let oversized = "1".repeat(4096);
let result = service.verify_code("13800138020", &oversized).await;
assert!(
matches!(result, Err(GarrisonError::InvalidParam(ref m)) if m.starts_with(service::ERR_SMS_CODE_WRONG)),
"超长验证码应按错误验证码拒绝,实际: {:?}",
result
);
let result = service.verify_code("13800138020", "12345").await;
assert!(matches!(result, Err(GarrisonError::InvalidParam(_))));
let attempts = dao.get("sms:attempts:13800138020").await.unwrap();
assert_eq!(
attempts,
Some("2".to_string()),
"长度不符的输入应计入失败尝试"
);
}
#[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
);
}
}
#[test]
fn validate_phone_rejects_empty() {
let result = rate_limiter::validate_phone("");
assert!(
matches!(&result, Err(GarrisonError::InvalidParam(msg)) if msg.contains("secure-phone-empty")),
"空手机号应返回 InvalidParam(secure-phone-empty),实际: {:?}",
result
);
}
#[test]
fn validate_phone_rejects_colon() {
let result = rate_limiter::validate_phone("138:00138000");
assert!(
matches!(&result, Err(GarrisonError::InvalidParam(msg)) if msg.contains("secure-phone-no-colon")),
"含冒号手机号应返回 InvalidParam(secure-phone-no-colon),实际: {:?}",
result
);
}
#[test]
fn validate_phone_rejects_control_char() {
for phone in ["138\n00138000", "138\u{1}00138000"] {
let result = rate_limiter::validate_phone(phone);
assert!(
matches!(&result, Err(GarrisonError::InvalidParam(msg)) if msg.contains("secure-phone-no-control-char")),
"含控制字符手机号应返回 InvalidParam(secure-phone-no-control-char),实际: {:?}",
result
);
}
}
#[test]
fn validate_phone_rejects_over_20_chars() {
let result = rate_limiter::validate_phone(&"1".repeat(21));
assert!(
matches!(&result, Err(GarrisonError::InvalidParam(msg)) if msg.contains("secure-phone-too-long")),
"21 字符手机号应返回 InvalidParam(secure-phone-too-long),实际: {:?}",
result
);
assert!(
rate_limiter::validate_phone(&"1".repeat(20)).is_ok(),
"恰好 20 字符应放行(边界值)"
);
}
#[test]
fn validate_phone_accepts_valid() {
assert!(rate_limiter::validate_phone("13800138000").is_ok());
assert!(rate_limiter::validate_phone("+8613800138000").is_ok());
}
struct FaultDao {
inner: MockDao,
fail_incr: bool,
fail_decr: bool,
}
impl FaultDao {
fn ok() -> Self {
Self {
inner: MockDao::new(),
fail_incr: false,
fail_decr: false,
}
}
fn with_fail_incr() -> Self {
Self {
inner: MockDao::new(),
fail_incr: true,
fail_decr: false,
}
}
fn with_fail_decr() -> Self {
Self {
inner: MockDao::new(),
fail_incr: false,
fail_decr: true,
}
}
}
#[async_trait]
impl GarrisonDao for FaultDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
self.inner.get(key).await
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
self.inner.set(key, value, ttl_seconds).await
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
self.inner.update(key, value).await
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
self.inner.expire(key, seconds).await
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
self.inner.delete(key).await
}
async fn set_if_absent(
&self,
key: &str,
value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
self.inner.set_if_absent(key, value, ttl_seconds).await
}
async fn rename(&self, old_key: &str, new_key: &str) -> GarrisonResult<()> {
self.inner.rename(old_key, new_key).await
}
async fn get_and_delete(&self, key: &str) -> GarrisonResult<Option<String>> {
self.inner.get_and_delete(key).await
}
async fn keys(&self, pattern: &str) -> GarrisonResult<Vec<String>> {
self.inner.keys(pattern).await
}
async fn compare_and_swap(
&self,
key: &str,
expected: Option<&str>,
new_value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
self.inner
.compare_and_swap(key, expected, new_value, ttl_seconds)
.await
}
async fn incr(&self, key: &str, ttl_seconds: u64) -> GarrisonResult<u64> {
if self.fail_incr {
return Err(GarrisonError::Dao("mock-incr-failed".to_string()));
}
self.inner.incr(key, ttl_seconds).await
}
async fn decr(&self, key: &str) -> GarrisonResult<u64> {
if self.fail_decr {
return Err(GarrisonError::Dao("mock-decr-failed".to_string()));
}
self.inner.decr(key).await
}
}
async fn window_counter_value(
dao: &Arc<dyn GarrisonDao>,
phone: &str,
window: &str,
) -> Option<String> {
dao.get(&format!("quota:{}:sms:{}", window, phone))
.await
.unwrap()
}
#[tokio::test]
async fn check_and_increment_hourly_exceed_rolls_back_counter() {
let dao: Arc<dyn GarrisonDao> = Arc::new(FaultDao::ok());
let limiter = SmsRateLimiter::new(dao.clone(), 1, 100);
limiter.check_and_increment("15800000001").await.unwrap();
let result = limiter.check_and_increment("15800000001").await;
assert!(
matches!(&result, Err(GarrisonError::SmsRateLimitExceeded { window }) if window == "hourly"),
"第 2 次应返回 hourly 限流错误,实际: {:?}",
result
);
assert_eq!(
window_counter_value(&dao, "15800000001", "hour").await,
Some("1".to_string()),
"超限请求应回滚:hour 计数应回到拒绝前的 1"
);
}
#[tokio::test]
async fn check_and_increment_daily_exceed_rolls_back_both_counters() {
let dao: Arc<dyn GarrisonDao> = Arc::new(FaultDao::ok());
let limiter = SmsRateLimiter::new(dao.clone(), 100, 1);
limiter.check_and_increment("15800000002").await.unwrap();
let result = limiter.check_and_increment("15800000002").await;
assert!(
matches!(&result, Err(GarrisonError::SmsRateLimitExceeded { window }) if window == "daily"),
"第 2 次应返回 daily 限流错误,实际: {:?}",
result
);
assert_eq!(
window_counter_value(&dao, "15800000002", "day").await,
Some("1".to_string()),
"超限请求应回滚:day 计数应回到拒绝前的 1"
);
assert_eq!(
window_counter_value(&dao, "15800000002", "hour").await,
Some("1".to_string()),
"超限请求应回滚:hour 计数应回到拒绝前的 1"
);
}
#[tokio::test]
async fn check_and_increment_hourly_exceed_rollback_failure_only_warns() {
let dao: Arc<dyn GarrisonDao> = Arc::new(FaultDao::with_fail_decr());
let limiter = SmsRateLimiter::new(dao, 0, 100);
let result = limiter.check_and_increment("15800000003").await;
assert!(
matches!(&result, Err(GarrisonError::SmsRateLimitExceeded { window }) if window == "hourly"),
"回滚失败不应改变返回值,仍应返回 hourly 限流错误,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_and_increment_daily_exceed_rollback_failure_only_warns() {
let dao: Arc<dyn GarrisonDao> = Arc::new(FaultDao::with_fail_decr());
let limiter = SmsRateLimiter::new(dao, 100, 0);
let result = limiter.check_and_increment("15800000004").await;
assert!(
matches!(&result, Err(GarrisonError::SmsRateLimitExceeded { window }) if window == "daily"),
"回滚失败不应改变返回值,仍应返回 daily 限流错误,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_and_increment_incr_failure_returns_internal() {
let dao: Arc<dyn GarrisonDao> = Arc::new(FaultDao::with_fail_incr());
let limiter = SmsRateLimiter::new(dao, 100, 100);
let result = limiter.check_and_increment("15800000005").await;
assert!(
matches!(&result, Err(GarrisonError::Internal(msg)) if msg.contains("secure-limiter-incr")),
"incr 失败应返回 Internal(secure-limiter-incr),实际: {:?}",
result
);
}
#[tokio::test]
async fn rollback_decrements_hour_and_day_counters() {
let dao: Arc<dyn GarrisonDao> = Arc::new(FaultDao::ok());
let limiter = SmsRateLimiter::new(dao.clone(), 100, 100);
limiter.check_and_increment("15800000006").await.unwrap();
assert_eq!(
window_counter_value(&dao, "15800000006", "hour").await,
Some("1".to_string())
);
limiter.rollback("15800000006").await.unwrap();
assert_eq!(
window_counter_value(&dao, "15800000006", "hour").await,
None,
"回滚后 hour 计数器应被删除(递减到 0)"
);
assert_eq!(
window_counter_value(&dao, "15800000006", "day").await,
None,
"回滚后 day 计数器应被删除(递减到 0)"
);
}
#[tokio::test]
async fn rollback_invalid_phone_returns_invalid_param() {
let dao: Arc<dyn GarrisonDao> = Arc::new(FaultDao::ok());
let limiter = SmsRateLimiter::new(dao, 100, 100);
let result = limiter.rollback("158:0000007").await;
assert!(
matches!(&result, Err(GarrisonError::InvalidParam(msg)) if msg.contains("secure-phone-no-colon")),
"回滚含冒号手机号应返回 InvalidParam,实际: {:?}",
result
);
}
#[tokio::test]
async fn rollback_decr_failure_propagates_error() {
let dao: Arc<dyn GarrisonDao> = Arc::new(FaultDao::with_fail_decr());
let limiter = SmsRateLimiter::new(dao, 100, 100);
let result = limiter.rollback("15800000008").await;
assert!(
matches!(&result, Err(GarrisonError::Dao(msg)) if msg.contains("mock-decr-failed")),
"回滚 decr 失败应透传 Dao 错误,实际: {:?}",
result
);
}
#[tokio::test]
async fn rollback_with_uses_check_windows() {
let dao: Arc<dyn GarrisonDao> = Arc::new(FaultDao::ok());
let limiter = SmsRateLimiter::new(dao.clone(), 100, 100);
let windows = limiter
.check_and_increment_with("15800000009")
.await
.unwrap();
assert_eq!(
window_counter_value(&dao, "15800000009", "hour").await,
Some("1".to_string())
);
limiter
.rollback_with("15800000009", &windows)
.await
.unwrap();
assert_eq!(
window_counter_value(&dao, "15800000009", "hour").await,
None,
"rollback_with 后 hour 计数器应被删除"
);
assert_eq!(
window_counter_value(&dao, "15800000009", "day").await,
None,
"rollback_with 后 day 计数器应被删除"
);
}
#[tokio::test]
async fn check_and_increment_normalizes_phone_whitespace() {
let dao: Arc<dyn GarrisonDao> = Arc::new(FaultDao::ok());
let limiter = SmsRateLimiter::new(dao.clone(), 100, 100);
limiter
.check_and_increment(" 15800000010 ")
.await
.unwrap();
let value = dao.get("quota:hour:sms:15800000010").await.unwrap();
assert!(
value.is_some(),
"归一化手机号应生成 quota:hour:sms:15800000010 的账本 key"
);
limiter.check_and_increment("15800000010").await.unwrap();
let value = window_counter_value(&dao, "15800000010", "hour")
.await
.expect("两个请求应命中同一归一化 key");
assert_eq!(value, "2", "空白填充与裸手机号应共用同一账本");
let padded_keys = dao.keys("quota:*:sms: *").await.unwrap();
assert!(
padded_keys.is_empty(),
"不应存在含空白填充的限速 key,实际: {:?}",
padded_keys
);
}
#[test]
fn validate_phone_rejects_inner_whitespace() {
let result = rate_limiter::validate_phone("138 0013 8000");
assert!(
matches!(&result, Err(GarrisonError::InvalidParam(msg)) if msg.contains("secure-phone-no-whitespace")),
"内部空白手机号应返回 InvalidParam(secure-phone-no-whitespace),实际: {:?}",
result
);
}
#[tokio::test]
async fn correct_code_after_max_attempts_still_rejected() {
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(), 100, 100),
sender.clone(),
dao.clone(),
3,
100,
);
let phone = "13800138012";
service.send_code(phone).await.unwrap();
let correct_code = sender.code.lock().as_ref().cloned().unwrap();
for _ in 0..3 {
let r = service.verify_code(phone, "000000").await;
assert!(matches!(r, Err(GarrisonError::InvalidParam(_))));
}
let r = service.verify_code(phone, "000000").await;
assert!(
matches!(r, Err(GarrisonError::SmsVerifyMaxAttempts)),
"第 4 次错误应返回 SmsVerifyMaxAttempts"
);
let result = service.verify_code(phone, &correct_code).await;
assert!(
result.is_err(),
"达上限后正确验证码必须被拒绝(验证码已随 MaxAttempts 失效),实际: {:?}",
result
);
assert!(
!matches!(&result, Err(GarrisonError::InvalidParam(m)) if m.starts_with(service::ERR_SMS_CODE_WRONG)),
"达上限后正确验证码不应返回 code-wrong(新尝试窗口),实际: {:?}",
result
);
}
struct FailingSmsSender;
#[async_trait]
impl SmsSender for FailingSmsSender {
async fn send(&self, _phone: &str, _code: &str) -> GarrisonResult<()> {
Err(GarrisonError::Internal("gateway-down".to_string()))
}
}
#[tokio::test]
async fn send_failure_cleans_stored_code_and_keeps_original_error() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let service = SmsVerificationService::new(
SmsRateLimiter::new(dao.clone(), 5, 10),
Arc::new(FailingSmsSender),
dao.clone(),
3,
100,
);
let result = service.send_code("13800138010").await;
assert!(
matches!(&result, Err(GarrisonError::Internal(m)) if m == "gateway-down"),
"应保留原始发送错误,实际: {:?}",
result
);
let code = "123456";
let verify = service.verify_code("13800138010", code).await;
assert!(
matches!(&verify, Err(GarrisonError::SmsCodeNotFound)),
"发送失败后验证码不应可验证(已清理),实际: {:?}",
verify
);
}
struct UnverifiedIncrFaultDao {
inner: MockDao,
}
#[async_trait]
impl GarrisonDao for UnverifiedIncrFaultDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
self.inner.get(key).await
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
self.inner.set(key, value, ttl_seconds).await
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
self.inner.update(key, value).await
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
self.inner.expire(key, seconds).await
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
self.inner.delete(key).await
}
async fn set_if_absent(
&self,
key: &str,
value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
self.inner.set_if_absent(key, value, ttl_seconds).await
}
async fn rename(&self, old_key: &str, new_key: &str) -> GarrisonResult<()> {
self.inner.rename(old_key, new_key).await
}
async fn get_and_delete(&self, key: &str) -> GarrisonResult<Option<String>> {
self.inner.get_and_delete(key).await
}
async fn keys(&self, pattern: &str) -> GarrisonResult<Vec<String>> {
self.inner.keys(pattern).await
}
async fn compare_and_swap(
&self,
key: &str,
expected: Option<&str>,
new_value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
self.inner
.compare_and_swap(key, expected, new_value, ttl_seconds)
.await
}
async fn incr(&self, key: &str, ttl_seconds: u64) -> GarrisonResult<u64> {
if key.starts_with("sms:unverified:") {
return Err(GarrisonError::Dao("unverified-incr-failed".to_string()));
}
self.inner.incr(key, ttl_seconds).await
}
async fn decr(&self, key: &str) -> GarrisonResult<u64> {
self.inner.decr(key).await
}
}
#[tokio::test]
async fn unverified_incr_failure_rolls_back_limiter_and_code() {
let dao: Arc<dyn GarrisonDao> = Arc::new(UnverifiedIncrFaultDao {
inner: MockDao::new(),
});
let service = SmsVerificationService::new(
SmsRateLimiter::new(dao.clone(), 5, 10),
Arc::new(NoopSmsSender),
dao.clone(),
3,
100,
);
let result = service.send_code("13800138011").await;
assert!(
matches!(&result, Err(GarrisonError::Dao(m)) if m == "unverified-incr-failed"),
"应保留 unverified incr 的原始错误,实际: {:?}",
result
);
let code = dao.get("sms:code:13800138011").await.unwrap();
assert!(code.is_none(), "unverified incr 失败后验证码应被删除");
let hourly = window_counter_value(&dao, "13800138011", "hour").await;
assert!(
hourly.is_none() || hourly.as_deref() == Some("0"),
"限速计数应回滚,实际: {:?}",
hourly
);
}