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
// Copyright (c) 2026 Kirky.X🌠
// SPDX-License-Identifier: Apache-2.0

//! qrlogin 协议模块单元测试。
//!
//! 覆盖:构造校验、serde 往返、create/scan/confirm/poll 全状态机路径、
//! 票据签名与域名白名单、原子兑换并发语义。

use super::QrLoginService;
use super::{
    QrLoginAction, QrLoginConfig, QrLoginPollOutcome, QrLoginSessionData, QrLoginStatus,
    QrLoginWebContext,
};
use crate::dao::InMemoryDao;
use crate::error::GarrisonError;
use crate::i18n::{set_locale, GarrisonLocale};
use std::sync::Arc;

/// 构造默认配置的测试服务。
fn service() -> QrLoginService {
    QrLoginService::new(
        Arc::new(InMemoryDao::new()),
        "test-secret-key-0123456789abcdef-0123456789abcdef",
    )
    .unwrap()
}

/// 构造带域名白名单的测试服务。
fn service_with_domains(domains: &[&str]) -> QrLoginService {
    QrLoginService::new(
        Arc::new(InMemoryDao::new()),
        "test-secret-key-0123456789abcdef-0123456789abcdef",
    )
    .unwrap()
    .with_config(QrLoginConfig {
        allowed_domains: Some(domains.iter().map(|s| (*s).to_string()).collect()),
        ..Default::default()
    })
}

/// 构造待登录端上下文。
fn web_context() -> QrLoginWebContext {
    QrLoginWebContext {
        ip: Some("203.0.113.7".to_string()),
        user_agent: Some(
            "Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 Chrome/126.0 Safari/537.36"
                .to_string(),
        ),
        created_at_ms: 1_725_000_000_000,
    }
}

/// 从 qr_content 提取 t 参数票据(测试断言验签用)。
fn ticket_of(qr_content: &str) -> &str {
    qr_content
        .split("t=")
        .nth(1)
        .expect("qr_content 应含 t= 参数")
}

/// 断言错误消息含指定英文文案片段(loc! 命中 FTL 与 fallback 的 En 文案一致,
/// 断言稳定;locale 显式锁 En 消除系统探测差异)。
fn assert_error_text(err: &GarrisonError, text: &str) {
    set_locale(GarrisonLocale::En);
    let rendered = match err {
        GarrisonError::InvalidParam(m)
        | GarrisonError::InvalidToken(m)
        | GarrisonError::Dao(m)
        | GarrisonError::Internal(m) => m.clone(),
        other => format!("{other:?}"),
    };
    assert!(rendered.contains(text), "应含 {text:?},实际: {rendered}");
}

// 构造校验与 serde

/// 空 secret 拒绝构造,错误为 InvalidParam。
#[tokio::test]
async fn new_rejects_empty_secret() {
    let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
    let err = QrLoginService::new(Arc::new(InMemoryDao::new()), "")
        .expect_err("empty secret must be rejected");
    assert_error_text(&err, "secret must not be empty");
}

/// 31 字节 secret 拒绝构造(强度下限 = 32 字节,对齐 JWT HS256)。
#[tokio::test]
async fn new_rejects_short_secret() {
    let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
    let err = QrLoginService::new(Arc::new(InMemoryDao::new()), "a".repeat(31))
        .expect_err("31-byte secret must be rejected");
    assert_error_text(&err, "at least 32 bytes");
}

/// 32 字节 secret 恰好通过强度下限。
#[tokio::test]
async fn new_accepts_32_byte_secret() {
    let svc = QrLoginService::new(Arc::new(InMemoryDao::new()), "b".repeat(32))
        .expect("32-byte secret must be accepted");
    assert!(
        svc.with_config(QrLoginConfig::default())
            .config
            .session_ttl_secs
            > 0
    );
}

#[test]
fn session_data_serde_roundtrip() {
    let data = QrLoginSessionData {
        qr_id: "abc123".to_string(),
        status: QrLoginStatus::Scanned,
        tenant_id: 3,
        app_login_id: Some("user-1".to_string()),
        confirm_token_hash: Some("deadbeef".to_string()),
        web: web_context(),
    };
    let json = serde_json::to_string(&data).unwrap();
    let back: QrLoginSessionData = serde_json::from_str(&json).unwrap();
    assert_eq!(back.qr_id, data.qr_id);
    assert_eq!(back.status, data.status);
    assert_eq!(back.tenant_id, data.tenant_id);
    assert_eq!(back.app_login_id, data.app_login_id);
    assert_eq!(back.confirm_token_hash, data.confirm_token_hash);
    assert_eq!(back.web.ip, data.web.ip);
    assert_eq!(back.web.user_agent, data.web.user_agent);
    assert_eq!(back.web.created_at_ms, data.web.created_at_ms);
}

/// tenant_id 缺省反序列化为 0(serde default)。
#[test]
fn session_data_tenant_defaults_to_zero() {
    let json = r#"{"qr_id":"x","status":"Pending","web":{}}"#;
    let data: QrLoginSessionData = serde_json::from_str(json).unwrap();
    assert_eq!(data.tenant_id, 0);
    assert_eq!(data.status, QrLoginStatus::Pending);
    assert!(data.app_login_id.is_none());
    assert_eq!(data.web.created_at_ms, 0);
}

// create / scan / confirm / poll 状态机

/// create 返回可验签的 qr_content,会话落盘为 Pending。
#[tokio::test]
async fn create_issues_signed_ticket_and_pending_session() {
    let svc = service();
    let created = svc.create_session(web_context()).await.unwrap();
    assert_eq!(created.expires_in_secs, 120);
    assert_eq!(created.qr_id.len(), 64, "qr_id 应为 64 hex");
    assert_eq!(created.bind_token.len(), 64, "bind_token 应为 64 hex");
    // 二维码票据不得携带 bind_token(它是 poll 第二票,仅 create 响应下发)
    assert!(
        !created.qr_content.contains(&created.bind_token),
        "二维码内容不得泄露 bind_token"
    );
    // qr_content 的 t 参数票据可验签还原 qr_id
    let qr_id = svc
        .verify_ticket_signature(ticket_of(&created.qr_content))
        .unwrap();
    assert_eq!(qr_id, created.qr_id);

    let data = svc.load_session(&created.qr_id).await.unwrap().unwrap();
    assert_eq!(data.status, QrLoginStatus::Pending);
    assert_eq!(data.web.ip.as_deref(), Some("203.0.113.7"));
}

/// scan:Pending → Scanned,颁发一次性 confirm_token 与脱敏摘要。
#[tokio::test]
async fn scan_moves_pending_to_scanned_and_issues_confirm_token() {
    let svc = service();
    let created = svc.create_session(web_context()).await.unwrap();

    let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
    assert_eq!(view.expires_in_secs, 60);
    assert_eq!(view.web_created_at_ms, 1_725_000_000_000);
    assert_eq!(view.web_device_label, "Chrome", "UA 应解析为 Chrome");
    assert!(!view.confirm_token.is_empty());

    let data = svc.load_session(&created.qr_id).await.unwrap().unwrap();
    assert_eq!(data.status, QrLoginStatus::Scanned);
    assert_eq!(data.app_login_id.as_deref(), Some("user-1"));
    assert_eq!(
        data.confirm_token_hash.as_deref(),
        Some(QrLoginService::token_digest(&view.confirm_token).as_str())
    );
}

/// scan:非法签名票据拒绝(无白名单配置时跳过域名校验,仍验签)。
#[tokio::test]
async fn scan_rejects_forged_ticket() {
    let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
    let svc = service();
    let err = svc
        .scan(
            "garrison://qrlogin?t=forged_random.not_a_valid_sig",
            "user-1",
            None,
        )
        .await
        .unwrap_err();
    assert_error_text(&err, "ticket signature is invalid");
}

/// scan:白名单模式下 create 使用白名单域名拼 qr_content,scan 放行。
#[tokio::test]
async fn scan_allows_allowlisted_domain() {
    let svc = service_with_domains(&["app.example.com"]);
    let created = svc.create_session(web_context()).await.unwrap();
    assert!(
        created.qr_content.starts_with("https://app.example.com/"),
        "白名单模式下 qr_content 应使用白名单域名,实际: {}",
        created.qr_content
    );
    svc.scan(&created.qr_content, "user-1", None).await.unwrap();
}

/// scan:白名单外域名的 qr_content 拒绝。
#[tokio::test]
async fn scan_rejects_non_allowlisted_domain() {
    let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
    let svc = service_with_domains(&["app.example.com"]);
    let created = svc.create_session(web_context()).await.unwrap();
    // 篡改 host 为白名单外域名(票据本身不变)
    let ticket = ticket_of(&created.qr_content);
    let evil = format!("https://evil.example.com/qrlogin/confirm?t={ticket}");
    let err = svc.scan(&evil, "user-1", None).await.unwrap_err();
    assert_error_text(&err, "domain is not allowed");
}

/// scan:重复扫码返回 already-scanned;App 取消后再扫返回 cancelled。
#[tokio::test]
async fn scan_rejects_repeated_scan_and_cancelled_session() {
    let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
    let svc = service();
    let created = svc.create_session(web_context()).await.unwrap();
    svc.scan(&created.qr_content, "user-1", None).await.unwrap();
    let err = svc
        .scan(&created.qr_content, "user-1", None)
        .await
        .unwrap_err();
    assert_error_text(&err, "already been scanned");

    // App 确认页取消后再扫:cancelled
    let created2 = svc.create_session(web_context()).await.unwrap();
    let view2 = svc
        .scan(&created2.qr_content, "user-1", None)
        .await
        .unwrap();
    svc.confirm(&view2.confirm_token, "user-1", QrLoginAction::Cancel, None)
        .await
        .unwrap();
    let err2 = svc
        .scan(&created2.qr_content, "user-1", None)
        .await
        .unwrap_err();
    assert_error_text(&err2, "has been cancelled");
}

/// 非扫码者(另一登录用户)持他人 confirm_token 确认 → 拒绝,且错误与
/// 「token 无效」完全一致(身份绑定 + 防枚举)。
#[tokio::test]
async fn confirm_by_other_user_rejected_indistinguishable() {
    let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
    let svc = service();
    let created = svc.create_session(web_context()).await.unwrap();
    let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
    let err = svc
        .confirm(&view.confirm_token, "user-2", QrLoginAction::Confirm, None)
        .await
        .expect_err("other user must not confirm");
    assert_error_text(&err, "confirm token is invalid");

    // 对照组:真实无效 token 的错误文本必须逐字一致(无区分度)
    let svc2 = service();
    let err2 = svc2
        .confirm("nonexistent-token", "user-1", QrLoginAction::Confirm, None)
        .await
        .expect_err("invalid token must fail");
    assert_eq!(format!("{}", err), format!("{}", err2));
}

/// confirm:Scanned → Confirmed;confirm_token 重放失败。
#[tokio::test]
async fn confirm_moves_scanned_to_confirmed_and_replay_fails() {
    let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
    let svc = service();
    let created = svc.create_session(web_context()).await.unwrap();
    let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();

    svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, None)
        .await
        .unwrap();
    let data = svc.load_session(&created.qr_id).await.unwrap().unwrap();
    assert_eq!(data.status, QrLoginStatus::Confirmed);

    // 重放同一 confirm_token:原子消费后第二次失败
    let err = svc
        .confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, None)
        .await
        .unwrap_err();
    assert_error_text(&err, "confirm token is invalid");
}

/// confirm:未扫码会话(Pending)确认返回 not-scanned。
#[tokio::test]
async fn confirm_pending_session_fails() {
    let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
    let svc = service();
    let created = svc.create_session(web_context()).await.unwrap();
    // 直接注入一个与 qr_id 关联的 confirm token(模拟 scan 后又手动回退状态的异常路径)
    let token = "pending-path-confirm-token";
    svc.store_confirm_token_for_test(token, &created.qr_id)
        .await;
    let err = svc
        .confirm(token, "user-1", QrLoginAction::Confirm, None)
        .await
        .unwrap_err();
    assert_error_text(&err, "has not been scanned");
}

/// cancel:App 端取消动作迁移 Cancelled,poll 返回 Cancelled。
#[tokio::test]
async fn cancel_action_moves_to_cancelled() {
    let svc = service();
    let created = svc.create_session(web_context()).await.unwrap();
    let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
    svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Cancel, None)
        .await
        .unwrap();
    assert_eq!(
        svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
        QrLoginPollOutcome::Cancelled
    );
}

/// poll:Confirmed 分支原子兑换,并发仅一胜出。
#[tokio::test]
async fn poll_confirmed_exchanges_atomically() {
    let svc = Arc::new(service());
    let created = svc.create_session(web_context()).await.unwrap();
    let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
    svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, None)
        .await
        .unwrap();

    let s1 = Arc::clone(&svc);
    let s2 = Arc::clone(&svc);
    let qr_id = created.qr_id.clone();
    let bind = created.bind_token.clone();
    let (r1, r2) = tokio::join!(s1.poll(&qr_id, &bind), s2.poll(&qr_id, &bind));
    let outcomes = [r1.unwrap(), r2.unwrap()];
    let confirmed = outcomes
        .iter()
        .filter(|o| matches!(o, QrLoginPollOutcome::Confirmed { .. }))
        .count();
    let expired = outcomes
        .iter()
        .filter(|o| matches!(o, QrLoginPollOutcome::Expired))
        .count();
    assert_eq!(confirmed, 1, "并发兑换仅一者成功");
    assert_eq!(expired, 1, "另一者应见 Expired");
    if let QrLoginPollOutcome::Confirmed { login_id, .. } = &outcomes[0] {
        assert_eq!(login_id, "user-1");
    }
}

/// poll:未扫码/已扫码/不存在 各返回对应 outcome;兑换后再 confirm 返回 already-consumed。
#[tokio::test]
async fn poll_outcomes_and_post_exchange_confirm() {
    let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
    let svc = service();
    let created = svc.create_session(web_context()).await.unwrap();
    assert_eq!(
        svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
        QrLoginPollOutcome::Pending
    );
    let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
    assert_eq!(
        svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
        QrLoginPollOutcome::Scanned
    );
    assert_eq!(
        svc.poll("nonexistent-qr-id", &created.bind_token)
            .await
            .unwrap(),
        QrLoginPollOutcome::Expired
    );

    svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, None)
        .await
        .unwrap();
    assert!(matches!(
        svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
        QrLoginPollOutcome::Confirmed { .. }
    ));
    // 兑换后重放已消费的 confirm_token:原子消费先于状态检查,fail-closed
    let err = svc
        .confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, None)
        .await
        .unwrap_err();
    assert_error_text(&err, "confirm token is invalid");
}

/// confirm:Cancel 后重放同一 confirm_token 失败(原子消费先于状态检查,fail-closed)。
#[tokio::test]
async fn confirm_replay_after_cancel_fails_fail_closed() {
    let _en = crate::i18n::set_locale(crate::i18n::GarrisonLocale::En);
    let svc = service();
    let created = svc.create_session(web_context()).await.unwrap();
    let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
    svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Cancel, None)
        .await
        .unwrap();
    assert_eq!(
        svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
        QrLoginPollOutcome::Cancelled
    );
    // 重放已消费的 token:token 查找失败优先于会话状态分支
    let err = svc
        .confirm(&view.confirm_token, "user-1", QrLoginAction::Cancel, None)
        .await
        .unwrap_err();
    assert_error_text(&err, "confirm token is invalid");
}

/// 双票:错误 bind_token → Expired(无区分度)。
#[tokio::test]
async fn poll_with_wrong_bind_token_is_expired() {
    let svc = service();
    let created = svc.create_session(web_context()).await.unwrap();
    assert_eq!(
        svc.poll(&created.qr_id, "wrong-bind-token").await.unwrap(),
        QrLoginPollOutcome::Expired
    );
}

/// 双票:非终态轮询不消费 bind_token(可循环轮询),Confirmed 兑换消费后
/// 重放 → Expired(第二票一次性)。
#[tokio::test]
async fn poll_bind_token_replay_is_expired() {
    let svc = service();
    let created = svc.create_session(web_context()).await.unwrap();
    assert_eq!(
        svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
        QrLoginPollOutcome::Pending
    );
    // 非终态:bind_token 未消费,可继续轮询
    assert_eq!(
        svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
        QrLoginPollOutcome::Pending
    );
    // Confirmed 兑换消费第二票
    let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
    svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, None)
        .await
        .unwrap();
    assert!(matches!(
        svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
        QrLoginPollOutcome::Confirmed { .. }
    ));
    assert_eq!(
        svc.poll(&created.qr_id, &created.bind_token).await.unwrap(),
        QrLoginPollOutcome::Expired,
        "重放已消费的 bind_token 必须 Expired"
    );
}

/// scan/confirm 的 app_context 应进入广播事件的 request_context(listener feature 下验证)。
#[cfg(all(feature = "listener", feature = "protocol-qrlogin"))]
mod app_context_event_tests {
    use super::*;
    use crate::error::GarrisonResult;
    use crate::listener::{GarrisonEvent, GarrisonListener, GarrisonListenerManager};
    use std::sync::Mutex;

    struct CapturingListener(Mutex<Vec<GarrisonEvent>>);

    #[async_trait::async_trait]
    impl GarrisonListener for CapturingListener {
        async fn on_event(&self, event: &GarrisonEvent) -> GarrisonResult<()> {
            self.0.lock().unwrap().push(event.clone());
            Ok(())
        }
    }

    fn ctx() -> Option<(String, String)> {
        Some(("198.51.100.9".to_string(), "TestAgent/1.0".to_string()))
    }

    /// scan 事件的 request_context 携带 App 端 IP/UA。
    #[tokio::test]
    async fn scan_event_carries_app_context() {
        let captured = std::sync::Arc::new(CapturingListener(Mutex::new(Vec::new())));
        let lm = GarrisonListenerManager::new();
        lm.register(std::sync::Arc::clone(&captured) as std::sync::Arc<dyn GarrisonListener>);

        let svc = service().with_listener_manager(std::sync::Arc::new(lm));
        let created = svc.create_session(web_context()).await.unwrap();
        let view = svc
            .scan(&created.qr_content, "user-1", ctx())
            .await
            .unwrap();
        let _ = view.confirm_token;

        let events = captured.0.lock().unwrap();
        let scanned = events
            .iter()
            .find_map(|e| match e {
                GarrisonEvent::QrLoginScanned {
                    app_login_id,
                    request_context,
                    ..
                } => Some((app_login_id.clone(), request_context.clone())),
                _ => None,
            })
            .expect("应广播 QrLoginScanned");
        assert_eq!(scanned.0, "user-1");
        let rc = scanned.1.expect("request_context 应非 None");
        assert_eq!(rc.ip.as_deref(), Some("198.51.100.9"));
        assert_eq!(rc.user_agent.as_deref(), Some("TestAgent/1.0"));
    }

    /// confirm 事件的 request_context 携带 App 端 IP/UA。
    #[tokio::test]
    async fn confirm_event_carries_app_context() {
        let captured = std::sync::Arc::new(CapturingListener(Mutex::new(Vec::new())));
        let lm = GarrisonListenerManager::new();
        lm.register(std::sync::Arc::clone(&captured) as std::sync::Arc<dyn GarrisonListener>);

        let svc = service().with_listener_manager(std::sync::Arc::new(lm));
        let created = svc.create_session(web_context()).await.unwrap();
        let view = svc
            .scan(&created.qr_content, "user-1", ctx())
            .await
            .unwrap();
        svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Confirm, ctx())
            .await
            .unwrap();

        let events = captured.0.lock().unwrap();
        let confirmed = events
            .iter()
            .find_map(|e| match e {
                GarrisonEvent::QrLoginConfirmed {
                    request_context, ..
                } => Some(request_context.clone()),
                _ => None,
            })
            .expect("应广播 QrLoginConfirmed");
        let rc = confirmed.expect("request_context 应非 None");
        assert_eq!(rc.ip.as_deref(), Some("198.51.100.9"));
    }
}

// Debug 脱敏 / 设备标签解析 / poll 防御分支

/// Debug 输出脱敏:secret 与 HMAC 密钥不得进 Debug(CWE-532)。
#[test]
fn debug_redacts_secret_and_hmac_key() {
    let secret = "test-secret-key-0123456789abcdef-0123456789abcdef";
    let svc = QrLoginService::new(Arc::new(InMemoryDao::new()), secret).unwrap();
    let s = format!("{svc:?}");
    assert!(s.contains("[REDACTED]"), "secret 应脱敏: {s}");
    assert!(!s.contains(secret), "Debug 不得包含 secret 原文: {s}");
}

/// scan 摘要的设备标签按 UA 解析:Edge 优先于 Chrome(特例序),未知 UA 兜底。
#[tokio::test]
async fn scan_device_label_parses_edge_firefox_safari_and_unknown() {
    let cases: &[(&str, &str)] = &[
        (
            "Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 Chrome/126.0 Safari/537.36 Edg/126.0",
            "Edge",
        ),
        ("Mozilla/5.0 (X11; Linux x86_64; rv:127.0) Gecko/20100101 Firefox/127.0", "Firefox"),
        ("Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1", "Safari"),
        ("curl/8.5.0", "Unknown device"),
    ];
    for (ua, expected) in cases {
        let svc = service();
        let ctx = QrLoginWebContext {
            ip: None,
            user_agent: Some((*ua).to_string()),
            created_at_ms: 1_725_000_000_000,
        };
        let created = svc.create_session(ctx).await.unwrap();
        let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
        assert_eq!(
            view.web_device_label, *expected,
            "UA「{ua}」应解析为 {expected}"
        );
    }
}

/// scan 摘要:无 UA(None)时设备标签为 Unknown device。
#[tokio::test]
async fn scan_device_label_without_user_agent_is_unknown() {
    let svc = service();
    let ctx = QrLoginWebContext {
        ip: None,
        user_agent: None,
        created_at_ms: 1_725_000_000_000,
    };
    let created = svc.create_session(ctx).await.unwrap();
    let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
    assert_eq!(view.web_device_label, "Unknown device");
}

/// poll:非 hex 形态的 qr_id / bind_token 直接 Expired(票据不得成为 DAO 键)。
#[tokio::test]
async fn poll_rejects_non_hex_ticket_shapes() {
    let svc = service();
    assert_eq!(
        svc.poll("short", "also-not-hex").await.unwrap(),
        QrLoginPollOutcome::Expired,
        "非 64-hex 形态应直接 Expired"
    );
    let long_non_hex = "z".repeat(64);
    assert_eq!(
        svc.poll(&long_non_hex, &long_non_hex).await.unwrap(),
        QrLoginPollOutcome::Expired
    );
}

/// poll:未知会话(64-hex 形态但不存在)返回 Expired,而非 panic / 内部错误。
#[tokio::test]
async fn poll_unknown_session_returns_expired() {
    let svc = service();
    let hex64 = "a".repeat(64);
    assert_eq!(
        svc.poll(&hex64, &hex64).await.unwrap(),
        QrLoginPollOutcome::Expired
    );
}

/// poll:bind_token 第二票不匹配(匿名端拿到他人 qr_id)一律 Expired,
/// 覆盖 Pending / Scanned / Cancelled 三态的错误票分支。
#[tokio::test]
async fn poll_with_wrong_bind_token_returns_expired_in_each_state() {
    // Pending 态:错票 → Expired
    let svc = service();
    let created = svc.create_session(web_context()).await.unwrap();
    let wrong_bind = "b".repeat(64);
    assert_eq!(
        svc.poll(&created.qr_id, &wrong_bind).await.unwrap(),
        QrLoginPollOutcome::Expired,
        "Pending 怕错票应 Expired"
    );

    // Scanned 态:错票 → Expired
    let view = svc.scan(&created.qr_content, "user-1", None).await.unwrap();
    assert_eq!(
        svc.poll(&created.qr_id, &wrong_bind).await.unwrap(),
        QrLoginPollOutcome::Expired
    );
    assert!(!view.confirm_token.is_empty());

    // Cancelled 态:错票 → Expired
    svc.confirm(&view.confirm_token, "user-1", QrLoginAction::Cancel, None)
        .await
        .unwrap();
    assert_eq!(
        svc.poll(&created.qr_id, &wrong_bind).await.unwrap(),
        QrLoginPollOutcome::Expired
    );
}