garrison 0.9.0

Garrison - 面向 Rust 生态的一站式身份认证鉴权框架
Documentation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
// Copyright (c) 2026 Kirky.X🌠
// SPDX-License-Identifier: Apache-2.0

//! `TotpHandler` 单元测试。

use super::TotpHandler;
use crate::dao::GarrisonDao;
use crate::error::GarrisonError;

/// RFC 6238 测试密钥(20 字节 ASCII)。
const TEST_SECRET: &[u8] = b"12345678901234567890";

// 构造测试

/// 使用默认参数构造 TotpHandler。
#[test]
fn new_with_default_params() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6);
    assert!(handler.is_ok());
}

/// 自定义时间步长与位数。
#[test]
fn new_with_custom_params() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 60, 8).unwrap();
    let code = handler.generate(1700000000).unwrap();
    assert_eq!(code.len(), 8);
}

/// 密钥过短应报错。
#[test]
fn new_with_short_secret_errors() {
    // totp-rs 要求密钥至少 10 字节
    let result = TotpHandler::new(b"short".to_vec(), 30, 6);
    assert!(result.is_err());
}

// generate 测试

/// 生成 6 位验证码。
#[test]
fn generate_returns_6_digits() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let code = handler.generate(1700000000).unwrap();
    assert_eq!(code.len(), 6);
    assert!(code.chars().all(|c| c.is_ascii_digit()));
}

/// 相同 secret + 时间戳生成一致验证码。
#[test]
fn generate_is_deterministic() {
    let h1 = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let h2 = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    assert_eq!(
        h1.generate(1700000000).unwrap(),
        h2.generate(1700000000).unwrap()
    );
}

/// 同一 30 秒窗口内验证码稳定。
#[test]
fn same_time_window_produces_same_code() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let c1 = handler.generate(1700000000).unwrap();
    let c2 = handler.generate(1700000005).unwrap(); // 同一窗口内
    assert_eq!(c1, c2);
}

/// 跨时间窗口验证码变化。
#[test]
fn different_time_window_produces_different_code() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let c1 = handler.generate(1700000000).unwrap();
    let c2 = handler.generate(1700000030).unwrap(); // 下一窗口
    assert_ne!(c1, c2);
}

/// 负时间戳 generate 返回 InvalidParam(不再静默回绕为巨大 u64 计数器)。
#[test]
fn generate_negative_now_returns_invalid_param() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let result = handler.generate(-1);
    assert!(
        matches!(&result, Err(GarrisonError::InvalidParam(msg)) if msg.contains("secure-totp-negative-now")),
        "负 now 应返回 InvalidParam(secure-totp-negative-now),实际: {:?}",
        result
    );
}

/// 负时间戳 validate 返回 InvalidParam。
#[test]
fn validate_negative_now_returns_invalid_param() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let result = handler.validate("123456", -1);
    assert!(
        matches!(&result, Err(GarrisonError::InvalidParam(msg)) if msg.contains("secure-totp-negative-now")),
        "负 now 应返回 InvalidParam(secure-totp-negative-now),实际: {:?}",
        result
    );
}

/// 负时间戳 validate_and_consume 返回 InvalidParam(且不写 replay_key)。
#[tokio::test]
async fn validate_and_consume_negative_now_returns_invalid_param() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();
    let result = handler
        .validate_and_consume("user-neg-now", "123456", -1, &dao)
        .await;
    assert!(
        matches!(&result, Err(GarrisonError::InvalidParam(msg)) if msg.contains("secure-totp-negative-now")),
        "负 now 应返回 InvalidParam(secure-totp-negative-now),实际: {:?}",
        result
    );
    // 不应留下 replay_key 残留
    let stored = dao.get("totp:used:user-neg-now:123456").await.unwrap();
    assert!(stored.is_none(), "负 now 拒绝时不应写入 replay_key");
}

// validate 测试

/// 当前窗口验证码校验通过。
#[test]
fn validate_current_window_succeeds() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let code = handler.generate(1700000000).unwrap();
    assert!(handler.validate(&code, 1700000000).unwrap());
}

/// 允许前一个时间窗口的验证码(±1 窗口容差)。
#[test]
fn validate_previous_window_succeeds() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let code = handler.generate(1699999970).unwrap(); // 前一窗口
    assert!(handler.validate(&code, 1700000000).unwrap());
}

/// 允许后一个时间窗口的验证码(±1 窗口容差)。
#[test]
fn validate_next_window_succeeds() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let code = handler.generate(1700000030).unwrap(); // 后一窗口
    assert!(handler.validate(&code, 1700000000).unwrap());
}

/// 超出容差窗口的验证码校验失败。
#[test]
fn validate_beyond_tolerance_fails() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let code = handler.generate(1699999940).unwrap(); // 前两个窗口
    assert!(!handler.validate(&code, 1700000000).unwrap());
}

/// 错误验证码校验失败。
#[test]
fn validate_wrong_code_fails() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    assert!(!handler.validate("000000", 1700000000).unwrap());
}

// secret_from_base32 测试

/// 解码合法 Base32 密钥。
#[test]
fn secret_from_base32_decodes_valid() {
    // 使用足够长的 Base32 字符串(解码后 >= 16 字节 / 128 位)
    let bytes = TotpHandler::secret_from_base32("JBSWY3DPEHPK3PXPJBSWY3DPEHPK3PXP").unwrap();
    assert!(!bytes.is_empty());
    assert!(bytes.len() >= 16); // 满足 totp-rs 的 128 位最低要求
}

/// 解码非法 Base32 字符串失败。
#[test]
fn secret_from_base32_rejects_invalid() {
    assert!(TotpHandler::secret_from_base32("invalid!base32").is_err());
}

/// Base32 密钥生成的验证码与原始字节一致。
#[test]
fn base32_secret_matches_raw_bytes() {
    let b32_str = "JBSWY3DPEHPK3PXPJBSWY3DPEHPK3PXP";
    let bytes = TotpHandler::secret_from_base32(b32_str).unwrap();
    let h1 = TotpHandler::new(bytes.clone(), 30, 6).unwrap();
    let h2 = TotpHandler::new(bytes, 30, 6).unwrap();
    assert_eq!(
        h1.generate(1700000000).unwrap(),
        h2.generate(1700000000).unwrap()
    );
}

// validate_and_consume 测试(重放防护)

/// 首次校验正确验证码返回 Ok(true)。
#[tokio::test]
async fn validate_and_consume_first_use_succeeds() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();
    let code = handler.generate(1700000000).unwrap();
    let result = handler
        .validate_and_consume("user-001", &code, 1700000000, &dao)
        .await;
    assert!(result.is_ok(), "validate_and_consume 不应报错");
    assert!(result.unwrap(), "首次使用正确验证码应返回 true");
}

/// 同一验证码第二次校验返回 Ok(false)(重放拒绝)。
#[tokio::test]
async fn validate_and_consume_rejects_replay() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();
    let code = handler.generate(1700000000).unwrap();

    let first = handler
        .validate_and_consume("user-001", &code, 1700000000, &dao)
        .await
        .expect("首次校验不应报错");
    assert!(first, "首次应通过");

    let second = handler
        .validate_and_consume("user-001", &code, 1700000000, &dao)
        .await
        .expect("二次校验不应报错");
    assert!(!second, "同一验证码二次使用应被拒绝(C-5 重放防护)");
}

/// 不同 login_id 的同一验证码不互相影响(隔离性)。
#[tokio::test]
async fn validate_and_consume_isolates_by_login_id() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();
    let code = handler.generate(1700000000).unwrap();

    let user_a = handler
        .validate_and_consume("user-A", &code, 1700000000, &dao)
        .await
        .unwrap();
    assert!(user_a, "user-A 首次应通过");

    let user_b = handler
        .validate_and_consume("user-B", &code, 1700000000, &dao)
        .await
        .unwrap();
    assert!(user_b, "user-B 使用同一验证码应通过(不同 login_id 隔离)");
}

/// 错误验证码返回 Ok(false) 且不记录到 DAO(不占用缓存)。
#[tokio::test]
async fn validate_and_consume_wrong_code_returns_false_without_recording() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();

    let result = handler
        .validate_and_consume("user-001", "000000", 1700000000, &dao)
        .await
        .unwrap();
    assert!(!result, "错误验证码应返回 false");

    let replay_key = "totp:used:user-001:000000";
    let stored = dao.get(replay_key).await.unwrap();
    assert!(
        stored.is_none(),
        "错误验证码不应记录到 DAO(避免无效码占用缓存)"
    );
}

/// 同一 login_id 使用不同验证码均通过(不同时间窗口的验证码不冲突)。
#[tokio::test]
async fn validate_and_consume_different_codes_both_succeed() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();
    let code1 = handler.generate(1700000000).unwrap();
    let code2 = handler.generate(1700000030).unwrap();

    if code1 == code2 {
        return;
    }

    let first = handler
        .validate_and_consume("user-001", &code1, 1700000000, &dao)
        .await
        .unwrap();
    assert!(first, "code1 应通过");

    let second = handler
        .validate_and_consume("user-001", &code2, 1700000030, &dao)
        .await
        .unwrap();
    assert!(second, "code2(不同窗口)应通过");
}

// TOCTOU 竞态防护

/// 10 个并发任务对同一 login_id + code 调用:应只有 1 个返回 `Ok(true)`,其余 9 个 `Ok(false)`(重放拒绝)。
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn validate_and_consume_concurrent_no_double_accept() {
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::sync::Arc;

    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = Arc::new(crate::dao::InMemoryDao::new());
    let code = handler.generate(1700000000).unwrap();
    let accept_count = Arc::new(AtomicUsize::new(0));

    let mut handles = Vec::new();
    for _ in 0..10 {
        let d = dao.clone();
        let ac = accept_count.clone();
        let code = code.clone();
        handles.push(tokio::spawn(async move {
            // 每个任务创建独立的 handler(同 secret → 同 code)
            let h = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
            let result = h
                .validate_and_consume("user-concurrent", &code, 1700000000, &*d)
                .await
                .unwrap();
            if result {
                ac.fetch_add(1, Ordering::SeqCst);
            }
        }));
    }
    for handle in handles {
        handle.await.unwrap();
    }

    assert_eq!(
        accept_count.load(Ordering::SeqCst),
        1,
        "并发调用同一 code 应只有 1 个通过(TOCTOU 防护),实际: {}",
        accept_count.load(Ordering::SeqCst)
    );
}

// DashMap → GarrisonDao::incr 原子性验证

/// 源码级守护测试:`include_str!` 读 handler.rs 并断言不再出现 DashMap / once_cell / TOTP_LOCKS 无界 static,
/// 防回归引入无界内存增长;只检查真实代码模式(import / 实例化 / static 声明),注释内容不计。
#[test]
fn e3_source_has_no_dashmap_or_unbounded_static() {
    let source = include_str!("handler.rs");
    // 过滤掉所有注释行(`//!` 模块文档、`///` 项文档、`//` 行注释),只检查真实代码
    let code_only: String = source
        .lines()
        .filter(|line| {
            let trimmed = line.trim_start();
            !(trimmed.starts_with("//!") || trimmed.starts_with("///") || trimmed.starts_with("//"))
        })
        .collect::<Vec<_>>()
        .join("\n");
    assert!(
        !code_only.contains("use dashmap"),
        "E3: handler.rs 代码不应再 import dashmap crate"
    );
    assert!(
        !code_only.contains("DashMap::new"),
        "E3: handler.rs 代码不应再实例化 DashMap"
    );
    assert!(
        !code_only.contains("DashMap<"),
        "E3: handler.rs 代码不应再使用 DashMap< 类型"
    );
    assert!(
        !code_only.contains("static TOTP_LOCKS"),
        "E3: handler.rs 代码不应再声明 TOTP_LOCKS 无界 static"
    );
    assert!(
        !code_only.contains("use once_cell"),
        "E3: handler.rs 代码不应再依赖 once_cell::sync::Lazy"
    );
    assert!(
        !code_only.contains("Lazy::new"),
        "E3: handler.rs 代码不应再使用 Lazy::new 初始化容器"
    );
    assert!(
        code_only.contains("dao.incr"),
        "E3: handler.rs 应使用 dao.incr 原子操作替代 per-login_id 锁"
    );
    // 文档注释中应保留 E3 修复说明(用于审计与回归防护)
    assert!(
        source.contains("E3 修复"),
        "E3: handler.rs 文档应保留 E3 修复说明"
    );
}

/// 直接调 InMemoryDao::incr 验证契约:key 不存在时初始化为 "1" 并返回 1。
#[tokio::test]
async fn e3_incr_returns_1_on_first_call() {
    let dao = crate::dao::InMemoryDao::new();
    let count = dao.incr("totp:used:user-001:123456", 90).await.unwrap();
    assert_eq!(count, 1, "E3: incr 首次调用应返回 1(视为首次使用验证码)");
}

/// 验证 `dao.incr` 在第二次调用时返回 2(重放检测)。
#[tokio::test]
async fn e3_incr_returns_2_on_replay() {
    let dao = crate::dao::InMemoryDao::new();
    let key = "totp:used:user-001:123456";
    let first = dao.incr(key, 90).await.unwrap();
    let second = dao.incr(key, 90).await.unwrap();
    assert_eq!(first, 1, "首次应返回 1");
    assert_eq!(
        second, 2,
        "E3: incr 第二次调用应返回 2(重放检测,>1 即拒绝)"
    );
}

/// 首次 validate_and_consume 后经 `dao.get_timeout` 验证 replay_key 形如 `totp:used:<login_id>:<code>`。
#[tokio::test]
async fn e3_replay_key_format_is_correct() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();
    let code = handler.generate(1700000000).unwrap();
    handler
        .validate_and_consume("user-format-test", &code, 1700000000, &dao)
        .await
        .unwrap();

    let expected_key = format!("totp:used:user-format-test:{}", code);
    let timeout = dao.get_timeout(&expected_key).await.unwrap();
    assert!(
        timeout.is_some(),
        "E3: replay_key 应存在且设置 TTL,格式: totp:used:<login_id>:<code>"
    );
}

/// replay_key 的 TTL = step * 3(step=30 → 90 秒,覆盖 skew=1 的三个时间窗口)。
#[tokio::test]
async fn e3_replay_key_ttl_is_step_times_3() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();
    let code = handler.generate(1700000000).unwrap();
    handler
        .validate_and_consume("user-ttl-30", &code, 1700000000, &dao)
        .await
        .unwrap();

    let replay_key = format!("totp:used:user-ttl-30:{}", code);
    let timeout = dao.get_timeout(&replay_key).await.unwrap();
    let remaining = timeout.expect("TTL 应存在");
    // 剩余 ≤ 90s(刚写入,应接近 90s)
    assert!(
        remaining.as_secs() <= 90,
        "E3: step=30 时 TTL 应 ≤ 90s,实际: {:?}",
        remaining
    );
    assert!(
        remaining.as_secs() > 85,
        "E3: step=30 时刚写入的 TTL 应接近 90s,实际: {:?}",
        remaining
    );
}

/// 不同 step 产生不同 TTL(step=60 → 180s)。
#[tokio::test]
async fn e3_step_60_produces_ttl_180() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 60, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();
    let code = handler.generate(1700000000).unwrap();
    handler
        .validate_and_consume("user-ttl-60", &code, 1700000000, &dao)
        .await
        .unwrap();

    let replay_key = format!("totp:used:user-ttl-60:{}", code);
    let timeout = dao.get_timeout(&replay_key).await.unwrap();
    let remaining = timeout.expect("TTL 应存在");
    assert!(
        remaining.as_secs() <= 180,
        "E3: step=60 时 TTL 应 ≤ 180s,实际: {:?}",
        remaining
    );
    assert!(
        remaining.as_secs() > 175,
        "E3: step=60 时刚写入的 TTL 应接近 180s,实际: {:?}",
        remaining
    );
}

/// 验证前一窗口(skew=1 容差内)的验证码首次使用应通过。
#[tokio::test]
async fn e3_previous_window_code_accepted_first_time() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();
    // 生成前一窗口的验证码(now-30s)
    let prev_code = handler.generate(1699999970).unwrap();
    let result = handler
        .validate_and_consume("user-prev-win", &prev_code, 1700000000, &dao)
        .await
        .unwrap();
    assert!(result, "E3: 前一窗口验证码首次使用应通过(skew=1 容差)");
}

/// 验证前一窗口的验证码重放应被拒绝。
#[tokio::test]
async fn e3_previous_window_code_rejected_on_replay() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();
    let prev_code = handler.generate(1699999970).unwrap();
    let first = handler
        .validate_and_consume("user-prev-replay", &prev_code, 1700000000, &dao)
        .await
        .unwrap();
    assert!(first, "首次应通过");
    let second = handler
        .validate_and_consume("user-prev-replay", &prev_code, 1700000000, &dao)
        .await
        .unwrap();
    assert!(!second, "E3: 前一窗口验证码重放应被拒绝(incr 返回 2 > 1)");
}

/// 10 个并发任务各用不同 login_id 但同一 code:应全部通过(跨 login_id 隔离)。
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn e3_concurrent_different_login_ids_no_interference() {
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::sync::Arc;

    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = Arc::new(crate::dao::InMemoryDao::new());
    let code = handler.generate(1700000000).unwrap();
    let accept_count = Arc::new(AtomicUsize::new(0));

    let mut handles = Vec::new();
    for i in 0..10 {
        let d = dao.clone();
        let ac = accept_count.clone();
        let code = code.clone();
        handles.push(tokio::spawn(async move {
            let h = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
            let login_id = format!("user-isolated-{}", i);
            let result = h
                .validate_and_consume(&login_id, &code, 1700000000, &*d)
                .await
                .unwrap();
            if result {
                ac.fetch_add(1, Ordering::SeqCst);
            }
        }));
    }
    for handle in handles {
        handle.await.unwrap();
    }

    assert_eq!(
        accept_count.load(Ordering::SeqCst),
        10,
        "E3: 10 个不同 login_id 的并发调用应全部通过(隔离性)"
    );
}

/// 验证不同 code 的 replay_key 互不影响(同一 login_id 的不同 code 都能首次通过)。
#[tokio::test]
async fn e3_replay_key_isolated_per_code() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();
    let code1 = handler.generate(1700000000).unwrap();
    let code2 = handler.generate(1700000030).unwrap();

    // 若两个窗口的 code 恰好相同(极小概率),跳过测试
    if code1 == code2 {
        return;
    }

    let r1 = handler
        .validate_and_consume("user-multi-code", &code1, 1700000000, &dao)
        .await
        .unwrap();
    let r2 = handler
        .validate_and_consume("user-multi-code", &code2, 1700000030, &dao)
        .await
        .unwrap();
    assert!(r1, "code1 首次应通过");
    assert!(
        r2,
        "E3: code2(不同窗口)首次应通过,replay_key 按 (login_id, code) 隔离"
    );

    let key1 = format!("totp:used:user-multi-code:{}", code1);
    let key2 = format!("totp:used:user-multi-code:{}", code2);
    let t1 = dao.get_timeout(&key1).await.unwrap();
    let t2 = dao.get_timeout(&key2).await.unwrap();
    assert!(t1.is_some(), "code1 的 replay_key 应存在");
    assert!(t2.is_some(), "code2 的 replay_key 应存在");
}

/// 验证错误验证码不调用 incr(不写入 replay_key,不占用缓存)。
#[tokio::test]
async fn e3_wrong_code_does_not_write_replay_key() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();
    let result = handler
        .validate_and_consume("user-wrong-code", "000000", 1700000000, &dao)
        .await
        .unwrap();
    assert!(!result, "错误验证码应返回 false");

    let replay_key = "totp:used:user-wrong-code:000000";
    let stored = dao.get(replay_key).await.unwrap();
    assert!(
        stored.is_none(),
        "E3: 错误验证码不应写入 replay_key(避免无效码占用缓存)"
    );
    let timeout = dao.get_timeout(replay_key).await.unwrap();
    assert!(timeout.is_none(), "E3: 错误验证码的 replay_key 不应有 TTL");
}

/// 验证 replay_key 的 incr 计数随重放次数递增(3 次重放后 count=4)。
#[tokio::test]
async fn e3_incr_count_increments_with_replays() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 6).unwrap();
    let dao = crate::dao::InMemoryDao::new();
    let code = handler.generate(1700000000).unwrap();
    let replay_key = format!("totp:used:user-count:{}", code);

    // 首次通过 + 3 次重放
    for i in 0..4 {
        let result = handler
            .validate_and_consume("user-count", &code, 1700000000, &dao)
            .await
            .unwrap();
        if i == 0 {
            assert!(result, "首次应通过");
        } else {
            assert!(!result, "第 {} 次重放应被拒绝", i);
        }
    }

    // 直接验证 incr 计数 = 4
    let stored = dao.get(&replay_key).await.unwrap();
    assert_eq!(
        stored,
        Some("4".to_string()),
        "E3: 4 次调用后 replay_key 的 incr 计数应为 4"
    );
}

// RFC 6238 Appendix B 官方向量(行为锁定)

/// RFC 6238 Appendix B SHA1 官方向量(密钥 `12345678901234567890`,20 字节 ASCII,step=30,8 位模式);
/// 任一向量不符即为实现缺陷,须修复实现而非放宽断言。
#[test]
fn rfc6238_appendix_b_sha1_official_vectors() {
    let handler = TotpHandler::new(TEST_SECRET.to_vec(), 30, 8).unwrap();

    // (T, 期望 8 位 TOTP),取自 RFC 6238 Appendix B SHA1 组
    let vectors: &[(i64, &str)] = &[
        (59, "94287082"),
        (1_111_111_109, "07081804"),
        (1_111_111_111, "14050471"),
        (1_234_567_890, "89005924"),
        (2_000_000_000, "69279037"),
        (20_000_000_000, "65353130"),
    ];

    for (t, expected) in vectors {
        let code = handler.generate(*t).unwrap();
        assert_eq!(
            code, *expected,
            "T={t} 的 TOTP 应为官方向量 {expected}(RFC 6238 Appendix B SHA1)"
        );
    }
}

/// RFC 6238 Appendix B SHA256 官方向量(密钥 `12345678901234567890123456789012`,32 字节 ASCII,step=30,8 位模式)。
#[test]
fn rfc6238_appendix_b_sha256_official_vectors() {
    use totp_rs::Algorithm;

    let secret = b"12345678901234567890123456789012";
    let handler =
        TotpHandler::new_with_hash_algorithm(secret.to_vec(), 30, 8, Algorithm::SHA256).unwrap();

    // (T, 期望 8 位 TOTP),取自 RFC 6238 Appendix B SHA256 组
    let vectors: &[(i64, &str)] = &[
        (59, "46119246"),
        (1_111_111_109, "68084774"),
        (1_111_111_111, "67062674"),
        (1_234_567_890, "91819424"),
        (2_000_000_000, "90698825"),
        (20_000_000_000, "77737706"),
    ];

    for (t, expected) in vectors {
        let code = handler.generate(*t).unwrap();
        assert_eq!(
            code, *expected,
            "T={t} 的 TOTP 应为官方向量 {expected}(RFC 6238 Appendix B SHA256)"
        );
    }
}

/// RFC 6238 Appendix B SHA512 官方向量(密钥 `1234567890...1234`,64 字节 ASCII,step=30,8 位模式)。
#[test]
fn rfc6238_appendix_b_sha512_official_vectors() {
    use totp_rs::Algorithm;

    let secret = b"1234567890123456789012345678901234567890123456789012345678901234";
    let handler =
        TotpHandler::new_with_hash_algorithm(secret.to_vec(), 30, 8, Algorithm::SHA512).unwrap();

    // (T, 期望 8 位 TOTP),取自 RFC 6238 Appendix B SHA512 组
    let vectors: &[(i64, &str)] = &[
        (59, "90693936"),
        (1_111_111_109, "25091201"),
        (1_111_111_111, "99943326"),
        (1_234_567_890, "93441116"),
        (2_000_000_000, "38618901"),
        (20_000_000_000, "47863826"),
    ];

    for (t, expected) in vectors {
        let code = handler.generate(*t).unwrap();
        assert_eq!(
            code, *expected,
            "T={t} 的 TOTP 应为官方向量 {expected}(RFC 6238 Appendix B SHA512)"
        );
    }
}