use super::strategy::now_timestamp;
use super::*;
use crate::dao::tests::MockDao;
use crate::error::GarrisonError;
use crate::strategy::firewall::{FirewallContext, GarrisonFirewallStrategy, StrategyRegistration};
use std::sync::Arc;
#[test]
fn config_default_matches_spec() {
let config = UserLockoutConfig::default();
assert_eq!(config.max_failure_factor, 5);
assert!(config.permanent_lockout);
assert_eq!(config.max_temporary_lockouts, 3);
assert_eq!(config.failure_window_seconds, 300);
match &config.wait_strategy {
WaitStrategy::Multiple {
base_seconds,
multiplier,
} => {
assert_eq!(*base_seconds, 60);
assert_eq!(*multiplier, 2);
},
other => panic!("默认 wait_strategy 应为 Multiple,实际: {:?}", other),
}
}
#[test]
fn wait_strategy_multiple_serde_roundtrip() {
let strategy = WaitStrategy::Multiple {
base_seconds: 60,
multiplier: 2,
};
let json = serde_json::to_string(&strategy).expect("序列化 Multiple 失败");
let deserialized: WaitStrategy = serde_json::from_str(&json).expect("反序列化 Multiple 失败");
match deserialized {
WaitStrategy::Multiple {
base_seconds,
multiplier,
} => {
assert_eq!(base_seconds, 60);
assert_eq!(multiplier, 2);
},
other => panic!("反序列化后应为 Multiple,实际: {:?}", other),
}
}
#[test]
fn wait_strategy_linear_serde_roundtrip() {
let strategy = WaitStrategy::Linear { base_seconds: 30 };
let json = serde_json::to_string(&strategy).expect("序列化 Linear 失败");
let deserialized: WaitStrategy = serde_json::from_str(&json).expect("反序列化 Linear 失败");
match deserialized {
WaitStrategy::Linear { base_seconds } => {
assert_eq!(base_seconds, 30);
},
other => panic!("反序列化后应为 Linear,实际: {:?}", other),
}
}
#[test]
fn lockout_state_serde_roundtrip() {
let state = LockoutState {
failure_count: 3,
temporary_lockout_count: 1,
permanent_locked: false,
locked_until: 1700000000,
first_failure_at: Some(1699999900),
};
let json = serde_json::to_string(&state).expect("序列化 LockoutState 失败");
let deserialized: LockoutState =
serde_json::from_str(&json).expect("反序列化 LockoutState 失败");
assert_eq!(deserialized.failure_count, 3);
assert_eq!(deserialized.temporary_lockout_count, 1);
assert!(!deserialized.permanent_locked);
assert_eq!(deserialized.locked_until, 1700000000);
}
#[test]
fn config_custom_construction() {
let config = UserLockoutConfig {
max_failure_factor: 10,
permanent_lockout: false,
max_temporary_lockouts: 5,
wait_strategy: WaitStrategy::Linear { base_seconds: 30 },
failure_window_seconds: 600,
};
assert_eq!(config.max_failure_factor, 10);
assert!(!config.permanent_lockout);
assert_eq!(config.max_temporary_lockouts, 5);
assert_eq!(config.failure_window_seconds, 600);
assert!(matches!(
config.wait_strategy,
WaitStrategy::Linear { base_seconds: 30 }
));
}
#[test]
fn lockout_state_default_is_clean() {
let state = LockoutState::default();
assert_eq!(state.failure_count, 0);
assert_eq!(state.temporary_lockout_count, 0);
assert!(!state.permanent_locked);
assert_eq!(state.locked_until, 0);
}
#[test]
fn wait_strategy_multiple_formula() {
let base = 60u64;
let multiplier = 2u32;
let n1 = base * (multiplier.pow(0) as u64);
assert_eq!(n1, 60);
let n2 = base * (multiplier.pow(1) as u64);
assert_eq!(n2, 120);
let n3 = base * (multiplier.pow(2) as u64);
assert_eq!(n3, 240);
}
#[test]
fn wait_strategy_linear_formula() {
let base = 30u64;
assert_eq!(base, 30);
assert_eq!(base * 2, 60);
assert_eq!(base * 3, 90);
}
fn make_strategy() -> (UserLockoutStrategy, Arc<dyn GarrisonDao>) {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let strategy = UserLockoutStrategy::new(UserLockoutConfig::default(), dao.clone());
(strategy, dao)
}
#[tokio::test]
async fn record_failure_first_does_not_lock() {
let (strategy, _) = make_strategy();
strategy.record_failure("user1").await.unwrap();
let ctx = FirewallContext::new("1.1.1.1").with_login_id("user1");
assert!(strategy.check(&ctx).await.is_ok(), "首次失败不应触发锁定");
}
#[tokio::test]
async fn record_failure_triggers_temporary_lock_at_threshold() {
let (strategy, _) = make_strategy();
for _ in 0..4 {
strategy.record_failure("user1").await.unwrap();
}
let ctx = FirewallContext::new("1.1.1.1").with_login_id("user1");
assert!(strategy.check(&ctx).await.is_ok(), "4 次失败不应触发锁定");
strategy.record_failure("user1").await.unwrap();
let result = strategy.check(&ctx).await;
assert!(
matches!(result, Err(GarrisonError::FirewallBlocked(_))),
"5 次失败应触发临时锁定,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_blocks_during_temporary_lockout() {
let (strategy, _) = make_strategy();
for _ in 0..5 {
strategy.record_failure("user1").await.unwrap();
}
let ctx = FirewallContext::new("1.1.1.1").with_login_id("user1");
let result = strategy.check(&ctx).await;
assert!(
matches!(result, Err(GarrisonError::FirewallBlocked(_))),
"临时锁定期内应拦截,实际: {:?}",
result
);
}
#[tokio::test]
async fn permanent_lockout_after_max_temporary_lockouts() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = UserLockoutConfig {
max_failure_factor: 2,
permanent_lockout: true,
max_temporary_lockouts: 1,
wait_strategy: WaitStrategy::Linear { base_seconds: 10 },
failure_window_seconds: 300,
};
let strategy = UserLockoutStrategy::new(config, dao);
strategy.record_failure("user1").await.unwrap();
strategy.record_failure("user1").await.unwrap();
strategy.record_failure("user1").await.unwrap();
strategy.record_failure("user1").await.unwrap();
let ctx = FirewallContext::new("1.1.1.1").with_login_id("user1");
let result = strategy.check(&ctx).await;
assert!(
matches!(result, Err(GarrisonError::FirewallBlocked(ref msg)) if msg.contains("永久锁定")),
"超过 max_temporary_lockouts 应永久锁定,实际: {:?}",
result
);
}
#[tokio::test]
async fn unlock_clears_lockout_state() {
let (strategy, _) = make_strategy();
for _ in 0..5 {
strategy.record_failure("user1").await.unwrap();
}
let ctx = FirewallContext::new("1.1.1.1").with_login_id("user1");
assert!(strategy.check(&ctx).await.is_err(), "解锁前应被拦截");
strategy.unlock("user1").await.unwrap();
assert!(strategy.check(&ctx).await.is_ok(), "解锁后应通过");
}
#[tokio::test]
async fn wait_strategy_multiple_record_failure_duration() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = UserLockoutConfig {
max_failure_factor: 1,
permanent_lockout: false,
max_temporary_lockouts: 99,
wait_strategy: WaitStrategy::Multiple {
base_seconds: 60,
multiplier: 2,
},
failure_window_seconds: 300,
};
let strategy = UserLockoutStrategy::new(config, dao);
strategy.record_failure("user1").await.unwrap();
let state = strategy.get_state("user1").await.unwrap();
let duration_1 = state.locked_until - now_timestamp();
assert!(
(55..=65).contains(&duration_1),
"第 1 次临时锁定时长应 ≈ 60,实际: {}",
duration_1
);
let mut state = strategy.get_state("user1").await.unwrap();
state.failure_count = 0;
state.locked_until = 0;
strategy.set_state("user1", &state).await.unwrap();
strategy.record_failure("user1").await.unwrap();
let state = strategy.get_state("user1").await.unwrap();
let duration_2 = state.locked_until - now_timestamp();
assert!(
(115..=125).contains(&duration_2),
"第 2 次临时锁定时长应 ≈ 120,实际: {}",
duration_2
);
}
#[tokio::test]
async fn wait_strategy_linear_record_failure_duration() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = UserLockoutConfig {
max_failure_factor: 1,
permanent_lockout: false,
max_temporary_lockouts: 99,
wait_strategy: WaitStrategy::Linear { base_seconds: 30 },
failure_window_seconds: 300,
};
let strategy = UserLockoutStrategy::new(config, dao);
strategy.record_failure("user1").await.unwrap();
let state = strategy.get_state("user1").await.unwrap();
let duration_1 = state.locked_until - now_timestamp();
assert!(
(25..=35).contains(&duration_1),
"第 1 次临时锁定时长应 ≈ 30,实际: {}",
duration_1
);
let mut state = strategy.get_state("user1").await.unwrap();
state.failure_count = 0;
state.locked_until = 0;
strategy.set_state("user1", &state).await.unwrap();
strategy.record_failure("user1").await.unwrap();
let state = strategy.get_state("user1").await.unwrap();
let duration_2 = state.locked_until - now_timestamp();
assert!(
(55..=65).contains(&duration_2),
"第 2 次临时锁定时长应 ≈ 60,实际: {}",
duration_2
);
}
#[tokio::test]
async fn record_success_resets_failure_count() {
let (strategy, _) = make_strategy();
for _ in 0..3 {
strategy.record_failure("user1").await.unwrap();
}
let state = strategy.get_state("user1").await.unwrap();
assert_eq!(state.failure_count, 3);
strategy.record_success("user1").await.unwrap();
let state = strategy.get_state("user1").await.unwrap();
assert_eq!(
state.failure_count, 0,
"record_success 后 failure_count 应为 0"
);
assert_eq!(
state.temporary_lockout_count, 0,
"temporary_lockout_count 不应变"
);
assert!(!state.permanent_locked, "permanent_locked 不应变");
assert_eq!(state.locked_until, 0, "locked_until 不应变");
}
#[tokio::test]
async fn failure_window_resets_count_after_expiry() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = UserLockoutConfig {
max_failure_factor: 5,
permanent_lockout: false,
max_temporary_lockouts: 99,
wait_strategy: WaitStrategy::Linear { base_seconds: 60 },
failure_window_seconds: 300,
};
let strategy = UserLockoutStrategy::new(config, dao.clone());
for _ in 0..3 {
strategy.record_failure("user1").await.unwrap();
}
let state = strategy.get_state("user1").await.unwrap();
assert_eq!(state.failure_count, 3);
assert!(state.first_failure_at.is_some());
let mut state = strategy.get_state("user1").await.unwrap();
state.first_failure_at = Some(now_timestamp() - 301);
strategy.set_state("user1", &state).await.unwrap();
strategy.record_failure("user1").await.unwrap();
let state = strategy.get_state("user1").await.unwrap();
assert_eq!(
state.failure_count, 1,
"窗口过期后 failure_count 应重置为 1,实际: {}",
state.failure_count
);
}
#[tokio::test]
async fn failure_window_accumulates_within_window() {
let (strategy, _) = make_strategy();
for i in 1..=4 {
strategy.record_failure("user1").await.unwrap();
let state = strategy.get_state("user1").await.unwrap();
assert_eq!(
state.failure_count, i,
"第 {} 次失败后 failure_count 应为 {}",
i, i
);
}
let state = strategy.get_state("user1").await.unwrap();
assert!(
state.first_failure_at.is_some(),
"first_failure_at 应已设置"
);
}
#[tokio::test]
async fn check_passes_after_temporary_lockout_expires() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = UserLockoutConfig {
max_failure_factor: 1,
permanent_lockout: false,
max_temporary_lockouts: 99,
wait_strategy: WaitStrategy::Linear { base_seconds: 1 },
failure_window_seconds: 300,
};
let strategy = UserLockoutStrategy::new(config, dao);
strategy.record_failure("user1").await.unwrap();
let ctx = FirewallContext::new("1.1.1.1").with_login_id("user1");
assert!(strategy.check(&ctx).await.is_err(), "锁定期内应拦截");
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
assert!(strategy.check(&ctx).await.is_ok(), "锁定到期后应通过");
}
#[tokio::test]
async fn check_skips_when_login_id_is_none() {
let (strategy, _) = make_strategy();
let ctx = FirewallContext::new("1.1.1.1");
assert!(strategy.check(&ctx).await.is_ok(), "login_id=None 时应跳过");
}
#[tokio::test]
async fn multi_user_isolation() {
let (strategy, _) = make_strategy();
for _ in 0..5 {
strategy.record_failure("alice").await.unwrap();
}
let ctx_a = FirewallContext::new("1.1.1.1").with_login_id("alice");
let ctx_b = FirewallContext::new("2.2.2.2").with_login_id("bob");
assert!(strategy.check(&ctx_a).await.is_err(), "用户 A 应被锁定");
assert!(strategy.check(&ctx_b).await.is_ok(), "用户 B 不应受影响");
}
#[test]
fn user_lockout_registered_via_inventory() {
use std::iter::Iterator;
let _ = std::any::TypeId::of::<UserLockoutStrategy>();
let names: Vec<&'static str> = inventory::iter::<StrategyRegistration>()
.map(|r| r.name)
.collect();
assert!(
names.contains(&"user-lockout"),
"inventory 应注册 user-lockout 策略,实际: {:?}",
names
);
}