use crate::constants::DaoKeyPrefix;
use crate::dao::GarrisonDao;
use crate::error::GarrisonResult;
use rand::RngExt;
use std::sync::Arc;
use uuid::Uuid;
const DEFAULT_TTL: u64 = 300;
const DEFAULT_MAX_ATTEMPTS: u32 = 5;
pub struct MathCaptchaProvider {
dao: Arc<dyn GarrisonDao>,
ttl: u64,
max_attempts: u32,
}
impl MathCaptchaProvider {
pub fn new(dao: Arc<dyn GarrisonDao>) -> Self {
Self {
dao,
ttl: DEFAULT_TTL,
max_attempts: DEFAULT_MAX_ATTEMPTS,
}
}
pub fn with_ttl(dao: Arc<dyn GarrisonDao>, ttl: u64) -> Self {
Self {
dao,
ttl,
max_attempts: DEFAULT_MAX_ATTEMPTS,
}
}
pub fn with_max_attempts(dao: Arc<dyn GarrisonDao>, max_attempts: u32) -> Self {
Self {
dao,
ttl: DEFAULT_TTL,
max_attempts,
}
}
pub async fn generate(&self) -> GarrisonResult<(String, String)> {
let mut rng = rand::rng();
let a: i32 = rng.random_range(1..=20);
let b: i32 = rng.random_range(1..=20);
let (op, answer) = if rng.random_bool(0.5) || a < b {
('+', a + b)
} else {
('-', a - b)
};
let challenge_id = Uuid::new_v4().to_string();
let key = format!("{}math:{}", DaoKeyPrefix::Captcha, challenge_id);
self.dao.set(&key, &answer.to_string(), self.ttl).await?;
let question = format!("{} {} {} = ?", a, op, b);
Ok((challenge_id, question))
}
pub async fn verify(&self, challenge_id: &str, answer: &str) -> GarrisonResult<bool> {
let key = format!("{}math:{}", DaoKeyPrefix::Captcha, challenge_id);
let stored = self.dao.get_and_delete(&key).await?;
let stored = match stored {
Some(s) => s,
None => return Ok(false),
};
let attempts_key = format!("{}attempts:{}", DaoKeyPrefix::Captcha, challenge_id);
if stored.trim() == answer.trim() {
let _ = self.dao.delete(&attempts_key).await.map_err(|e| {
tracing::warn!(
challenge_id,
error = %e,
"CAPTCHA attempts key delete failed (non-fatal, TTL will clean it up)"
);
});
return Ok(true);
}
let new_count = self.dao.incr(&attempts_key, self.ttl).await?;
if new_count >= self.max_attempts as u64 {
let _ = self.dao.delete(&attempts_key).await.map_err(|e| {
tracing::warn!(
challenge_id,
error = %e,
"CAPTCHA attempts key delete failed (non-fatal, TTL will clean it up)"
);
});
tracing::warn!(
challenge_id,
attempts = new_count,
max = self.max_attempts,
"CAPTCHA challenge discarded due to exceeding max attempts"
);
return Ok(false);
}
self.dao.set(&key, &stored, self.ttl).await?;
Ok(false)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::tests::MockDao;
#[tokio::test]
async fn generate_returns_nonempty_id_and_question() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let provider = MathCaptchaProvider::new(dao);
let (id, question) = provider.generate().await.expect("generate 不应报错");
assert!(!id.is_empty(), "challenge_id 不应为空");
assert!(!question.is_empty(), "题目不应为空");
}
#[tokio::test]
async fn verify_correct_answer_passes() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let provider = MathCaptchaProvider::new(dao);
let (id, question) = provider.generate().await.expect("generate 不应报错");
let parts: Vec<&str> = question.split(' ').collect();
assert_eq!(parts.len(), 5, "题目应为 'a op b = ?' 格式");
let a: i32 = parts[0].parse().expect("a 应为整数");
let b: i32 = parts[2].parse().expect("b 应为整数");
let expected = match parts[1] {
"+" => a + b,
"-" => a - b,
other => panic!("未知运算符: {}", other),
};
let ok = provider
.verify(&id, &expected.to_string())
.await
.expect("verify 不应报错");
assert!(ok, "正确答案应通过验证");
}
#[tokio::test]
async fn verify_incorrect_answer_returns_false() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let provider = MathCaptchaProvider::new(dao);
let (id, _question) = provider.generate().await.expect("generate 不应报错");
let ok = provider.verify(&id, "999").await.expect("verify 不应报错");
assert!(!ok, "错误答案应返回 false");
}
#[tokio::test]
async fn verify_nonexistent_id_returns_false() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let provider = MathCaptchaProvider::new(dao);
let ok = provider
.verify("nonexistent-id", "42")
.await
.expect("verify 不应报错");
assert!(!ok, "不存在的 challenge_id 应返回 false");
}
#[tokio::test]
async fn verify_is_one_time_use() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let provider = MathCaptchaProvider::new(dao);
let (id, question) = provider.generate().await.expect("generate 不应报错");
let parts: Vec<&str> = question.split(' ').collect();
let a: i32 = parts[0].parse().unwrap();
let b: i32 = parts[2].parse().unwrap();
let expected = if parts[1] == "+" { a + b } else { a - b };
let first = provider
.verify(&id, &expected.to_string())
.await
.expect("首次 verify 不应报错");
assert!(first, "首次正确答案应通过");
let second = provider
.verify(&id, &expected.to_string())
.await
.expect("二次 verify 不应报错");
assert!(
!second,
"验证通过后应一次性删除,二次 verify 同一答案应返回 false"
);
}
#[tokio::test]
async fn generate_produces_well_formed_question() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let provider = MathCaptchaProvider::new(dao);
for _ in 0..20 {
let (_id, question) = provider.generate().await.expect("generate 不应报错");
let parts: Vec<&str> = question.split(' ').collect();
assert_eq!(
parts.len(),
5,
"题目应为 5 段 'a op b = ?',实际: {:?}",
question
);
assert!(
parts[1] == "+" || parts[1] == "-",
"运算符应为 + 或 -,实际: {:?}",
parts[1]
);
assert_eq!(parts[3], "=", "第 4 段应为 =,实际: {:?}", parts[3]);
assert_eq!(parts[4], "?", "第 5 段应为 ?,实际: {:?}", parts[4]);
let a: i32 = parts[0].parse().expect("a 应为整数");
let b: i32 = parts[2].parse().expect("b 应为整数");
assert!((1..=20).contains(&a), "a 应在 1-20,实际: {}", a);
assert!((1..=20).contains(&b), "b 应在 1-20,实际: {}", b);
if parts[1] == "-" {
assert!(a >= b, "减法时 a >= b 确保非负,实际: {} - {}", a, b);
}
}
}
#[tokio::test]
async fn with_ttl_sets_custom_ttl() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let provider = MathCaptchaProvider::with_ttl(dao, 1);
let (id, _question) = provider.generate().await.expect("generate 不应报错");
tokio::time::sleep(std::time::Duration::from_secs(2)).await;
let ok = provider.verify(&id, "0").await.expect("verify 不应报错");
assert!(!ok, "TTL 过期后 verify 应返回 false");
}
#[tokio::test]
async fn verify_trims_whitespace() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let provider = MathCaptchaProvider::new(dao);
let (id, question) = provider.generate().await.expect("generate 不应报错");
let parts: Vec<&str> = question.split(' ').collect();
let a: i32 = parts[0].parse().unwrap();
let b: i32 = parts[2].parse().unwrap();
let expected = if parts[1] == "+" { a + b } else { a - b };
let ok = provider
.verify(&id, &format!(" {} ", expected))
.await
.expect("verify 不应报错");
assert!(ok, "带前后空白的答案应通过(trim)");
}
#[tokio::test]
async fn verify_invalidates_after_max_attempts() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let provider = MathCaptchaProvider::with_max_attempts(dao, 3);
let (id, _question) = provider.generate().await.expect("generate 不应报错");
for _ in 0..3 {
let ok = provider.verify(&id, "999").await.expect("verify 不应报错");
assert!(!ok, "错误答案应返回 false");
}
let ok = provider.verify(&id, "0").await.expect("verify 不应报错");
assert!(!ok, "超过最大尝试次数后 challenge 应已失效");
}
#[tokio::test]
async fn default_max_attempts_is_5() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let provider = MathCaptchaProvider::new(dao);
let (id, _question) = provider.generate().await.expect("generate 不应报错");
for _ in 0..5 {
let ok = provider.verify(&id, "999").await.expect("verify 不应报错");
assert!(!ok);
}
let ok = provider.verify(&id, "0").await.expect("verify 不应报错");
assert!(!ok, "默认 5 次后 challenge 应已失效");
}
#[tokio::test]
async fn correct_answer_passes_before_max_attempts() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let provider = MathCaptchaProvider::with_max_attempts(dao, 3);
let (id, question) = provider.generate().await.expect("generate 不应报错");
for _ in 0..2 {
provider.verify(&id, "999").await.expect("verify 不应报错");
}
let parts: Vec<&str> = question.split(' ').collect();
let a: i32 = parts[0].parse().unwrap();
let b: i32 = parts[2].parse().unwrap();
let expected = if parts[1] == "+" { a + b } else { a - b };
let ok = provider
.verify(&id, &expected.to_string())
.await
.expect("verify 不应报错");
assert!(ok, "未超过 max_attempts 时正确答案应通过");
}
}