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
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
// Copyright (c) 2026 Kirky.X🌠
// SPDX-License-Identifier: Apache-2.0

use super::mock::MockDao;
use super::*;
use crate::error::GarrisonError;
use std::time::{SystemTime, UNIX_EPOCH};

/// 创建 ApiKeyHandler(使用 MockDao)。
fn make_handler() -> ApiKeyHandler {
    let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
    ApiKeyHandler::new(dao).with_allow_global_verify(true)
}

/// 从双段 token(`key_id.key_secret`)提取公开 `key_id`,作为存储 key 后缀。
fn key_id_of(token: &str) -> &str {
    token
        .split_once('.')
        .expect("token 应为 key_id.key_secret 双段格式")
        .0
}

// ApiKeyHandler 构造测试

/// 构造 ApiKeyHandler。
#[test]
fn new_creates_handler() {
    let _handler = make_handler();
}

// generate 测试

/// 成功生成 API Key,返回 `key_id.key_secret` 双段格式(各 32 hex)。
#[tokio::test]
async fn generate_returns_dual_segment_format() {
    let handler = make_handler();
    let key = handler
        .generate("1001", vec!["read".into()], 3600)
        .await
        .unwrap();
    let (key_id, key_secret) = key
        .split_once('.')
        .expect("应为 key_id.key_secret 双段格式");
    assert_eq!(key_id.len(), 32);
    assert_eq!(key_secret.len(), 32);
    assert!(key_id.chars().all(|c| c.is_ascii_hexdigit()));
    assert!(key_secret.chars().all(|c| c.is_ascii_hexdigit()));
}

/// 复用同一 handler 多次生成不同 key。
#[tokio::test]
async fn generate_multiple_times_returns_different_keys() {
    let handler = make_handler();
    let k1 = handler.generate("1001", vec![], 3600).await.unwrap();
    let k2 = handler.generate("1001", vec![], 3600).await.unwrap();
    assert_ne!(k1, k2);
}

/// timeout <= 0 返回错误。
#[tokio::test]
async fn generate_zero_timeout_returns_error() {
    let handler = make_handler();
    let result = handler.generate("1001", vec![], 0).await;
    assert!(result.is_err());
}

/// key 前缀正确。
///
/// generate 默认 namespace="default",存储格式为
/// `garrison:apikey:default:<key>`。
#[tokio::test]
async fn generate_uses_correct_key_prefix() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let key = handler
        .generate("1001", vec!["read".into()], 3600)
        .await
        .unwrap();
    let dao_key = format!("garrison:apikey:default:{}", key_id_of(&key));
    let value = dao.get(&dao_key).await.unwrap();
    assert!(value.is_some());
    let info: ApiKeyInfo = serde_json::from_str(&value.unwrap()).unwrap();
    assert_eq!(info.login_id, "1001");
    assert_eq!(info.scopes, vec!["read".to_string()]);
    assert!(!info.revoked);
    assert_eq!(info.namespace, "default");
}

// verify 测试

/// 成功校验返回 ApiKeyInfo。
#[tokio::test]
async fn verify_success_returns_info() {
    let handler = make_handler();
    let key = handler
        .generate("1001", vec!["read".into(), "write".into()], 3600)
        .await
        .unwrap();
    let info = handler.verify(&key).await.unwrap();
    assert_eq!(info.login_id, "1001");
    assert_eq!(info.scopes, vec!["read".to_string(), "write".to_string()]);
    assert!(!info.revoked);
}

/// 校验不存在的 key 返回错误。
#[tokio::test]
async fn verify_nonexistent_returns_error() {
    let handler = make_handler();
    let result = handler.verify("nonexistent-key").await;
    assert!(result.is_err());
    match result.err() {
        Some(GarrisonError::InvalidToken(_)) => {},
        other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
    }
}

/// 校验已吊销的 key 返回错误。
#[tokio::test]
async fn verify_revoked_returns_error() {
    let handler = make_handler();
    let key = handler.generate("1001", vec![], 3600).await.unwrap();
    handler.revoke(&key).await.unwrap();
    let result = handler.verify(&key).await;
    assert!(result.is_err());
    match result.err() {
        Some(GarrisonError::InvalidToken(_)) => {},
        other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
    }
}

/// 校验已过期的 key 返回错误。
#[tokio::test]
async fn verify_expired_returns_error() {
    let handler = make_handler();
    // 生成一个 1 秒过期的 key
    let key = handler.generate("1001", vec![], 1).await.unwrap();
    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
    let result = handler.verify(&key).await;
    assert!(result.is_err());
    match result.err() {
        Some(GarrisonError::ExpiredToken(_)) => {},
        other => panic!("期望 ExpiredToken 错误,实际: {:?}", other),
    }
}

// revoke 测试

/// 成功吊销。
#[tokio::test]
async fn revoke_success() {
    let handler = make_handler();
    let key = handler.generate("1001", vec![], 3600).await.unwrap();
    let result = handler.revoke(&key).await;
    assert_eq!(result.unwrap(), (), "撤销存在的 API key 应返回 Ok(())");
    let verify_result = handler.verify(&key).await;
    assert!(
        matches!(verify_result, Err(GarrisonError::InvalidToken(_))),
        "已吊销 key verify 应返回 InvalidToken,实际: {:?}",
        verify_result
    );
}

/// 吊销不存在的 key 返回错误。
#[tokio::test]
async fn revoke_nonexistent_returns_error() {
    let handler = make_handler();
    let result = handler.revoke("nonexistent-key").await;
    assert!(result.is_err());
    match result.err() {
        Some(GarrisonError::InvalidToken(_)) => {},
        other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
    }
}

// rotate 测试

/// 成功轮换。
#[tokio::test]
async fn rotate_success() {
    let handler = make_handler();
    let old_key = handler
        .generate("1001", vec!["read".into()], 3600)
        .await
        .unwrap();
    let new_key = handler.rotate(&old_key).await.unwrap();
    assert_ne!(old_key, new_key);
    assert!(
        new_key.contains('.'),
        "新 key 应为 key_id.key_secret 双段格式"
    );
    let old_result = handler.verify(&old_key).await;
    assert!(old_result.is_err());
    let info = handler.verify(&new_key).await.unwrap();
    assert_eq!(info.login_id, "1001");
    assert_eq!(info.scopes, vec!["read".to_string()]);
}

/// 轮换不存在的 key 返回错误。
#[tokio::test]
async fn rotate_nonexistent_returns_error() {
    let handler = make_handler();
    let result = handler.rotate("nonexistent-key").await;
    assert!(result.is_err());
}

// MockDao 方法覆盖测试

/// 验证 MockDao::expire 和 delete 方法可正常调用(覆盖 trait 方法)。
#[tokio::test]
async fn mock_dao_expire_and_delete_covered() {
    let dao = MockDao::new();
    dao.set("k", "v", 3600).await.unwrap();

    dao.expire("k", 7200).await.unwrap();
    let got = dao.get("k").await.unwrap();
    assert_eq!(got, Some("v".to_string()));

    dao.delete("k").await.unwrap();
    let got = dao.get("k").await.unwrap();
    assert!(got.is_none());
}

/// 验证 generate 拒绝负数 timeout。
#[tokio::test]
async fn generate_negative_timeout_returns_error() {
    let handler = make_handler();
    let result = handler.generate("1001", vec![], -1).await;
    assert!(result.is_err());
    assert!(matches!(
        result.unwrap_err(),
        GarrisonError::InvalidParam(_)
    ));
}

/// 验证 revoke 后 rotate 返回错误(old_key 已吊销)。
#[tokio::test]
async fn rotate_revoked_key_returns_error() {
    let handler = make_handler();
    let key = handler
        .generate("1001", vec!["read".into()], 3600)
        .await
        .unwrap();
    handler.revoke(&key).await.unwrap();
    // 再 rotate 应失败(verify 会因 revoked 返回 InvalidToken)
    let result = handler.rotate(&key).await;
    assert!(result.is_err());
}

// LoginId newtype 接入(impl Into<LoginId>)

/// 验证 `ApiKeyHandler::generate` 接受 String 形式 login_id。
#[tokio::test]
async fn generate_accepts_login_id_numeric() {
    let handler = make_handler();
    let key = handler
        .generate("1001".to_string(), vec!["read".into()], 3600)
        .await
        .unwrap();
    let info = handler.verify(&key).await.unwrap();
    assert_eq!(info.login_id, "1001");
}

// API Key Namespace

/// ApiKeyInfo 序列化包含 namespace 字段。
#[test]
fn apikey_info_serializes_with_namespace() {
    let info = ApiKeyInfo {
        login_id: "1".to_string(),
        scopes: vec![],
        expire_at: 0,
        revoked: false,
        namespace: "internal".to_string(),
        ..Default::default()
    };
    let json = serde_json::to_string(&info).unwrap();
    assert!(json.contains("\"namespace\""), "JSON 应包含 namespace 字段");
    assert!(json.contains("\"internal\""), "namespace 值应为 internal");
}

/// generate_with_namespace 用 `garrison:apikey:<namespace>:<key>` 存储
#[tokio::test]
#[serial_test::serial]
async fn generate_with_namespace_stores_new_format_key() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let key = handler
        .generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
        .await
        .unwrap();
    // 存储路径:garrison:apikey:internal:<key_id>
    let dao_key = format!("garrison:apikey:internal:{}", key_id_of(&key));
    let value = dao.get(&dao_key).await.unwrap();
    assert!(value.is_some(), "key 应存在: {}", dao_key);
    let info: ApiKeyInfo = serde_json::from_str(&value.unwrap()).unwrap();
    assert_eq!(info.namespace, "internal");
    assert_eq!(info.login_id, "1001");
    // 无 namespace 的存储路径不应存在
    let ns_less_key = format!("garrison:apikey:{}", key_id_of(&key));
    let ns_less_value = dao.get(&ns_less_key).await.unwrap();
    assert!(ns_less_value.is_none(), "无 namespace 的存储路径不应存在");
}

/// list_by_namespace 返回指定 namespace 下未吊销的 ApiKeyInfo
#[tokio::test]
#[serial_test::serial]
async fn list_by_namespace_returns_only_matching_namespace() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    // internal namespace 下生成 1 个 key
    let _k1 = handler
        .generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
        .await
        .unwrap();
    // partner namespace 下生成 1 个 key
    let _k2 = handler
        .generate_with_namespace("2002", "partner", vec!["write".into()], 3600)
        .await
        .unwrap();
    let internal_keys = handler.list_by_namespace("internal").await.unwrap();
    assert_eq!(internal_keys.len(), 1, "internal namespace 应有 1 个 key");
    assert_eq!(internal_keys[0].login_id, "1001");
    assert_eq!(internal_keys[0].namespace, "internal");
    let partner_keys = handler.list_by_namespace("partner").await.unwrap();
    assert_eq!(partner_keys.len(), 1, "partner namespace 应有 1 个 key");
    assert_eq!(partner_keys[0].login_id, "2002");
    let empty = handler.list_by_namespace("nonexistent").await.unwrap();
    assert!(empty.is_empty(), "不存在的 namespace 应返回空 Vec");
}

/// list_by_namespace 过滤已吊销的 key
#[tokio::test]
#[serial_test::serial]
async fn list_by_namespace_filters_revoked_keys() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let k1 = handler
        .generate_with_namespace("1001", "internal", vec![], 3600)
        .await
        .unwrap();
    let _k2 = handler
        .generate_with_namespace("1002", "internal", vec![], 3600)
        .await
        .unwrap();
    handler.revoke(&k1).await.unwrap();
    let keys = handler.list_by_namespace("internal").await.unwrap();
    assert_eq!(keys.len(), 1, "吊销后应只剩 1 个未吊销 key");
    assert_eq!(keys[0].login_id, "1002");
}

/// namespace 隔离——verify_with_namespace 严格匹配 namespace
#[tokio::test]
#[serial_test::serial]
async fn verify_with_namespace_enforces_isolation() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let key = handler
        .generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
        .await
        .unwrap();
    // 用正确 namespace 校验应成功
    let info = handler
        .verify_with_namespace(&key, "internal")
        .await
        .unwrap();
    assert_eq!(info.login_id, "1001");
    assert_eq!(info.namespace, "internal");
    // 用错误 namespace 校验应失败(key 不存在该 namespace 下)
    let wrong = handler.verify_with_namespace(&key, "partner").await;
    assert!(
        matches!(wrong, Err(GarrisonError::InvalidToken(_))),
        "跨 namespace 校验应返回 InvalidToken,实际: {:?}",
        wrong
    );
}

/// 普通 verify(不带 namespace)能找到任意 namespace 下的 key
#[tokio::test]
#[serial_test::serial]
async fn verify_without_namespace_scans_all_namespaces() {
    let handler = make_handler();
    let key = handler
        .generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
        .await
        .unwrap();
    // 不带 namespace 的 verify 通过反向索引找到
    let info = handler.verify(&key).await.unwrap();
    assert_eq!(info.login_id, "1001");
    assert_eq!(info.namespace, "internal");
}

/// namespace 校验:空字符串、过长、非法字符与保留 `idx` 均返回 InvalidParam。
#[tokio::test]
async fn generate_with_namespace_validates_namespace() {
    let handler = make_handler();
    let r = handler.generate_with_namespace("1", "", vec![], 3600).await;
    assert!(
        matches!(r, Err(GarrisonError::InvalidParam(_))),
        "空 namespace 应报错"
    );
    // 过长(65 字符)
    let long_ns = "a".repeat(65);
    let r = handler
        .generate_with_namespace("1", &long_ns, vec![], 3600)
        .await;
    assert!(
        matches!(r, Err(GarrisonError::InvalidParam(_))),
        "65 字符 namespace 应报错"
    );
    // 非法字符(含空格)
    let r = handler
        .generate_with_namespace("1", "has space", vec![], 3600)
        .await;
    assert!(
        matches!(r, Err(GarrisonError::InvalidParam(_))),
        "含空格 namespace 应报错"
    );
    // 保留 namespace "idx"(与反向索引键空间 garrison:apikey:idx:<key_id> 碰撞)
    let r = handler
        .generate_with_namespace("1", "idx", vec![], 3600)
        .await;
    assert!(
        matches!(r, Err(GarrisonError::InvalidParam(_))),
        "保留 namespace idx 应报错(防与反向索引键碰撞导致数据覆盖)"
    );
    // 合法字符边界:64 字符、含 _ -
    let r = handler
        .generate_with_namespace("1", &"a".repeat(64), vec![], 3600)
        .await;
    assert!(r.is_ok(), "64 字符 namespace 应通过");
    let r = handler
        .generate_with_namespace("1", "ns_name-1", vec![], 3600)
        .await;
    assert!(r.is_ok(), "含 _ - 数字 的 namespace 应通过");
}

// 覆盖率补充:错误分支与边界路径

/// CWE-916:`public_key_ref` 用于事件广播 / 审计日志,绝不得暴露 key_secret。
///
/// - 双段 `key_id.key_secret` 只返回 key_id 部分;
/// - 不含 `.` 的输入截断为前 8 字符 + `…`,不落完整凭证。
#[cfg(feature = "listener")]
#[test]
fn public_key_ref_never_exposes_secret() {
    use super::handler::public_key_ref;
    // 双段格式:只返回 key_id
    let key_id = "a".repeat(32);
    let key_secret = "b".repeat(32);
    let full = format!("{}.{}", key_id, key_secret);
    let redacted = public_key_ref(&full);
    assert_eq!(redacted, key_id, "双段格式应只返回 key_id");
    assert!(
        !redacted.contains(&key_secret),
        "脱敏结果绝不得含 key_secret"
    );
    // 不含 `.` 的输入:截断为前 8 字符 + 省略号
    let undotted = "deadbeef".repeat(8); // 64 hex
    let redacted_undotted = public_key_ref(&undotted);
    assert_eq!(
        redacted_undotted, "deadbeef\u{2026}",
        "不含 `.` 的输入应截断为前 8 字符 + …"
    );
    assert!(
        redacted_undotted.chars().count() <= 9,
        "脱敏后长度应远小于原始输入,不足以还原"
    );
}

/// 验证 verify_with_namespace 在 JSON namespace 与请求 namespace 不匹配时返回 InvalidToken。
///
/// 覆盖 verify_with_namespace 中 namespace 二次校验失败分支。
///
/// 使用 `generate_with_namespace` 生成合法 key(带 secret_hash),再篡改存储的
/// JSON namespace 字段模拟存储错位 / 跨 namespace 攻击。
#[tokio::test]
#[serial_test::serial]
async fn verify_with_namespace_returns_error_when_namespace_mismatch() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    // 1. 在 "internal" namespace 下生成合法 key(带 secret_hash)
    let key = handler
        .generate_with_namespace("1001", "internal", vec![], 3600)
        .await
        .unwrap();
    let key_id = key_id_of(&key);
    let dao_key = format!("garrison:apikey:internal:{}", key_id);
    // 2. 读取存储的 ApiKeyInfo,篡改 namespace 为 "other"(模拟存储错位)
    let value = dao.get(&dao_key).await.unwrap().unwrap();
    let mut info: ApiKeyInfo = serde_json::from_str(&value).unwrap();
    info.namespace = "other".to_string();
    let tampered_value = serde_json::to_string(&info).unwrap();
    dao.set(&dao_key, &tampered_value, 3600).await.unwrap();
    // 3. verify_with_namespace 应返回 InvalidToken(namespace 不匹配)
    let result = handler.verify_with_namespace(&key, "internal").await;
    assert!(
        matches!(result, Err(GarrisonError::InvalidToken(ref msg)) if msg.starts_with("apikey-namespace-mismatch::")),
        "namespace 不匹配应返回 InvalidToken,实际: {:?}",
        result
    );
}

/// 验证 verify 在 value 不是有效 JSON 时返回 Internal 错误。
///
/// 覆盖 decode_and_check 的反序列化失败分支。
#[tokio::test]
async fn verify_returns_internal_error_when_json_invalid() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let key_id = "deadbeefdeadbeefdeadbeefdeadbeef"; // 32 hex
    let key_secret = "0123456789abcdef0123456789abcdef";
    let token = format!("{}.{}", key_id, key_secret);
    // 反向索引 → dao_key,value 为非法 JSON
    let dao_key = format!("garrison:apikey:default:{}", key_id);
    dao.set(&super::handler::idx_key_for(key_id), &dao_key, 3600)
        .await
        .unwrap();
    dao.set(&dao_key, "invalid-json", 3600).await.unwrap();
    let result = handler.verify(&token).await;
    assert!(
        matches!(result, Err(GarrisonError::Internal(ref msg)) if msg.contains("apikey-deserialize")),
        "无效 JSON 应返回 Internal 错误,实际: {:?}",
        result
    );
}

/// revoke 在存储 value 为非法 JSON 时返回 Internal 错误
/// (覆盖 revoke_at 的反序列化失败分支)。
#[tokio::test]
async fn revoke_returns_internal_error_when_json_invalid() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let key_id = "cafebeefcafebeefcafebeefcafebeef"; // 32 hex
    let key_secret = "0123456789abcdef0123456789abcdef";
    let token = format!("{}.{}", key_id, key_secret);
    // 反向索引 → dao_key,value 为非法 JSON
    let dao_key = format!("garrison:apikey:default:{}", key_id);
    dao.set(&super::handler::idx_key_for(key_id), &dao_key, 3600)
        .await
        .unwrap();
    dao.set(&dao_key, "invalid-json", 3600).await.unwrap();
    let result = handler.revoke(&token).await;
    assert!(
        matches!(result, Err(GarrisonError::Internal(ref msg)) if msg.contains("apikey-deserialize")),
        "无效 JSON 应返回 Internal 错误,实际: {:?}",
        result
    );
}

// 反向索引 O(1) 查询验证

/// `idx_key_for` 返回正确的索引 key 格式。
#[test]
fn e4_idx_key_for_returns_correct_format() {
    let key = "abcd1234".repeat(8); // 64 chars
    let idx_key = super::handler::idx_key_for(&key);
    assert_eq!(
        idx_key,
        format!("garrison:apikey:idx:{}", key),
        "E4: 索引 key 格式应为 garrison:apikey:idx:<key>"
    );
}

/// 源码守卫:handler.rs 不再使用 `"garrison:apikey:*:"` 全表扫描模式(verify/revoke
/// 旧 O(N) 路径;经 `include_str!` 过滤注释后检查)。`list_by_namespace` 的
/// `garrison:apikey:<namespace>:*`(通配符在末尾)不在禁用范围。
#[test]
fn e4_source_verify_revoke_have_no_keys_scan() {
    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");
    // 检查代码中不再出现 `garrison:apikey:*:` 模式(旧 verify/revoke 的 O(N) 扫描路径)。
    // 注意:`list_by_namespace` 使用 `garrison:apikey:<namespace>:*`(通配符在末尾),
    // 不匹配此模式,因此不受影响。
    assert!(
        !code_only.contains("\"garrison:apikey:*:"),
        "E4: handler.rs 代码不应再使用 garrison:apikey:*: 通配符扫描模式(verify/revoke 旧路径)"
    );
    assert!(
        code_only.contains("idx_key_for"),
        "E4: handler.rs 代码应使用 idx_key_for 构造反向索引 key"
    );
    assert!(
        code_only.contains("garrison:apikey:idx:"),
        "E4: handler.rs 代码应包含 garrison:apikey:idx: 索引 key 前缀"
    );
}

/// `generate_with_namespace` 同步写入反向索引:idx → dao_key。
#[tokio::test]
#[serial_test::serial]
async fn e4_generate_with_namespace_writes_reverse_index() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let key = handler
        .generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
        .await
        .unwrap();

    let idx_key = format!("garrison:apikey:idx:{}", key_id_of(&key));
    let idx_value = dao.get(&idx_key).await.unwrap();
    assert!(
        idx_value.is_some(),
        "E4: 反向索引 garrison:apikey:idx:<key_id> 应存在"
    );

    let expected_dao_key = format!("garrison:apikey:internal:{}", key_id_of(&key));
    assert_eq!(
        idx_value.unwrap(),
        expected_dao_key,
        "E4: 索引 value 应为 dao_key(garrison:apikey:<namespace>:<key>)"
    );
}

/// E4: 验证默认 `generate`(namespace="default")也写入反向索引。
#[tokio::test]
#[serial_test::serial]
async fn e4_generate_writes_reverse_index_default_namespace() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let key = handler.generate("1001", vec![], 3600).await.unwrap();

    let idx_key = format!("garrison:apikey:idx:{}", key_id_of(&key));
    let idx_value = dao.get(&idx_key).await.unwrap();
    assert!(idx_value.is_some(), "E4: 默认 generate 也应写入反向索引");

    let expected_dao_key = format!("garrison:apikey:default:{}", key_id_of(&key));
    assert_eq!(
        idx_value.unwrap(),
        expected_dao_key,
        "E4: 默认 namespace 的索引 value 应为 garrison:apikey:default:<key>"
    );
}

/// verify 经反向索引 O(1) 命中 key(不受 DAO 中大量其他 key 影响)。
#[tokio::test]
#[serial_test::serial]
async fn e4_verify_uses_reverse_index() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);

    // 预填充一些干扰 key(模拟生产环境中大量 key 共存的场景)
    for i in 0..50 {
        let noise_key = format!("garrison:apikey:noise:{}:{}", i, "a".repeat(64));
        dao.set(&noise_key, "noise", 3600).await.unwrap();
    }

    let key = handler
        .generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
        .await
        .unwrap();
    let info = handler.verify(&key).await.unwrap();
    assert_eq!(info.login_id, "1001");
    assert_eq!(info.namespace, "internal");
}

/// revoke 经反向索引找到 key。
#[tokio::test]
#[serial_test::serial]
async fn e4_revoke_uses_reverse_index() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let key = handler
        .generate_with_namespace("1001", "internal", vec!["read".into()], 3600)
        .await
        .unwrap();

    handler.revoke(&key).await.unwrap();

    let result = handler.verify(&key).await;
    assert!(
        matches!(result, Err(GarrisonError::InvalidToken(_))),
        "E4: revoke 后 verify 应返回 InvalidToken"
    );
}

/// 反向索引 TTL 与主 key 一致(用支持 TTL 跟踪的 `crate::dao::tests::MockDao` 验证)。
#[tokio::test]
#[serial_test::serial]
async fn e4_index_has_same_ttl_as_key() {
    let dao = Arc::new(crate::dao::tests::MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let timeout = 3600i64;
    let key = handler
        .generate_with_namespace("ttl-test", "internal", vec![], timeout)
        .await
        .unwrap();

    let dao_key = format!("garrison:apikey:internal:{}", key_id_of(&key));
    let idx_key = format!("garrison:apikey:idx:{}", key_id_of(&key));

    let key_ttl = dao.get_timeout(&dao_key).await.unwrap();
    let idx_ttl = dao.get_timeout(&idx_key).await.unwrap();

    assert!(key_ttl.is_some(), "E4: 主 key 应有 TTL");
    assert!(idx_ttl.is_some(), "E4: 反向索引应有 TTL(与主 key 一致)");

    let key_secs = key_ttl.unwrap().as_secs();
    let idx_secs = idx_ttl.unwrap().as_secs();
    // 两者都应 ≤ timeout(刚写入,接近 timeout)
    assert!(
        key_secs <= timeout as u64,
        "E4: 主 key TTL 应 ≤ {},实际: {}",
        timeout,
        key_secs
    );
    assert!(
        idx_secs <= timeout as u64,
        "E4: 索引 TTL 应 ≤ {},实际: {}",
        timeout,
        idx_secs
    );
    // 两者差距应 ≤ 2 秒(写入顺序相邻)
    let diff = key_secs.abs_diff(idx_secs);
    assert!(
        diff <= 2,
        "E4: 主 key 与索引的 TTL 差距应 ≤ 2s,实际: {}s",
        diff
    );
}

/// rotate 为新 key 写入反向索引,old_key 被吊销、new_key 有效。
#[tokio::test]
#[serial_test::serial]
async fn e4_rotate_writes_index_for_new_key() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let old_key = handler
        .generate("1001", vec!["read".into()], 3600)
        .await
        .unwrap();

    let new_key = handler.rotate(&old_key).await.unwrap();
    assert_ne!(old_key, new_key);

    let old_result = handler.verify(&old_key).await;
    assert!(old_result.is_err(), "old_key 应被吊销");

    let info = handler.verify(&new_key).await.unwrap();
    assert_eq!(info.login_id, "1001");

    let new_idx_key = format!("garrison:apikey:idx:{}", key_id_of(&new_key));
    let idx_value = dao.get(&new_idx_key).await.unwrap();
    assert!(idx_value.is_some(), "E4: rotate 后新 key 的反向索引应存在");
}

/// 多个 namespace 的 key 都有正确的反向索引。
#[tokio::test]
#[serial_test::serial]
async fn e4_multiple_namespaces_all_indexed() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);

    let k1 = handler
        .generate_with_namespace("1001", "internal", vec![], 3600)
        .await
        .unwrap();
    let k2 = handler
        .generate_with_namespace("2002", "partner", vec![], 3600)
        .await
        .unwrap();
    let k3 = handler
        .generate_with_namespace("3003", "default", vec![], 3600)
        .await
        .unwrap();

    for (key, ns) in &[(&k1, "internal"), (&k2, "partner"), (&k3, "default")] {
        let idx_key = format!("garrison:apikey:idx:{}", key_id_of(key));
        let idx_value = dao.get(&idx_key).await.unwrap();
        assert!(
            idx_value.is_some(),
            "E4: namespace={} 的 key 反向索引应存在",
            ns
        );
        let expected_dao_key = format!("garrison:apikey:{}:{}", ns, key_id_of(key));
        assert_eq!(
            idx_value.unwrap(),
            expected_dao_key,
            "E4: namespace={} 的索引 value 应为 {}",
            ns,
            expected_dao_key
        );
    }

    assert_eq!(handler.verify(&k1).await.unwrap().login_id, "1001");
    assert_eq!(handler.verify(&k2).await.unwrap().login_id, "2002");
    assert_eq!(handler.verify(&k3).await.unwrap().login_id, "3003");
}

/// verify 对不存在的 key 返回 InvalidToken(O(1) 路径,无扫描)。
#[tokio::test]
async fn e4_verify_nonexistent_key_returns_invalid_token() {
    let handler = make_handler();
    let result = handler.verify("nonexistent-key-12345").await;
    assert!(
        matches!(result, Err(GarrisonError::InvalidToken(_))),
        "E4: 不存在的 key 应返回 InvalidToken(无扫描),实际: {:?}",
        result
    );
}

/// revoke 对不存在的 key 返回 InvalidToken(O(1) 路径,无扫描)。
#[tokio::test]
async fn e4_revoke_nonexistent_key_returns_invalid_token() {
    let handler = make_handler();
    let result = handler.revoke("nonexistent-key-67890").await;
    assert!(
        matches!(result, Err(GarrisonError::InvalidToken(_))),
        "E4: 不存在的 key 应返回 InvalidToken(无扫描),实际: {:?}",
        result
    );
}

/// 索引存在但 dao_key 已被删除(索引残留):verify 取不到主记录,fail-closed
/// 返回 InvalidToken。
#[tokio::test]
#[serial_test::serial]
async fn e4_verify_falls_through_when_dao_key_deleted() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let key = handler
        .generate_with_namespace("1001", "internal", vec![], 3600)
        .await
        .unwrap();

    // 手动删除主 key(保留索引)
    let dao_key = format!("garrison:apikey:internal:{}", key_id_of(&key));
    dao.delete(&dao_key).await.unwrap();

    let result = handler.verify(&key).await;
    assert!(
        matches!(result, Err(GarrisonError::InvalidToken(_))),
        "E4: 索引存在但主 key 已删除时应返回 InvalidToken,实际: {:?}",
        result
    );
}

// CWE-916 哈希存储 + 双段格式 + 归属 + scope 校验 + 密钥管理

/// CWE-916: 存储的 value 不含明文 key_secret,仅含 sha256 哈希。
#[tokio::test]
#[serial_test::serial]
async fn stored_value_contains_no_plaintext_secret() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let key = handler
        .generate_with_namespace("1001", "internal", vec![], 3600)
        .await
        .unwrap();
    let (key_id, key_secret) = key.split_once('.').unwrap();
    let dao_key = format!("garrison:apikey:internal:{}", key_id);
    let value = dao.get(&dao_key).await.unwrap().unwrap();
    // 明文 secret 绝不应出现在存储中
    assert!(
        !value.contains(key_secret),
        "存储 value 不应包含明文 key_secret"
    );
    // 应含 secret 的 sha256 哈希
    let info: ApiKeyInfo = serde_json::from_str(&value).unwrap();
    assert_eq!(info.secret_hash.len(), 64, "secret_hash 应为 64 hex");
    assert!(info.secret_hash.chars().all(|c| c.is_ascii_hexdigit()));
    assert_ne!(info.secret_hash, *key_secret, "存储的应是哈希而非明文");
    // 真值断言:secret_hash 必须恰为 sha256(key_secret) 的 hex 编码。
    // 仅验 64 位 hex 格式无法发现哈希逻辑损坏(如存错字段、用错哈希函数)——
    // 那样的缺陷下格式断言依然全通过。
    use sha2::{Digest, Sha256};
    use std::fmt::Write;
    let mut hasher = Sha256::new();
    hasher.update(key_secret.as_bytes());
    let mut expected_hash = String::with_capacity(64);
    for byte in hasher.finalize() {
        let _ = write!(expected_hash, "{:02x}", byte);
    }
    assert_eq!(
        info.secret_hash, expected_hash,
        "secret_hash 应等于 sha256(key_secret) 的 hex 编码"
    );
}

/// CWE-916: key_id 正确但 key_secret 错误时校验失败(哈希不匹配)。
#[tokio::test]
#[serial_test::serial]
async fn verify_rejects_wrong_secret() {
    let handler = make_handler();
    let key = handler.generate("1001", vec![], 3600).await.unwrap();
    let (key_id, _) = key.split_once('.').unwrap();
    // 用正确 key_id 拼错误 secret
    let forged = format!("{}.{}", key_id, "f".repeat(32));
    let result = handler.verify(&forged).await;
    assert!(
        matches!(result, Err(GarrisonError::InvalidToken(ref m)) if m == "apikey-secret-mismatch"),
        "错误 secret 应返回 InvalidToken(secret-mismatch),实际: {:?}",
        result
    );
}

/// 生成时 owner_id 默认等于 login_id。
#[tokio::test]
async fn generate_sets_owner_id_to_login_id_by_default() {
    let handler = make_handler();
    let key = handler.generate("user-42", vec![], 3600).await.unwrap();
    let info = handler.verify(&key).await.unwrap();
    assert_eq!(info.owner_id.as_deref(), Some("user-42"));
}

/// generate_with_options 可显式指定 owner_id。
#[tokio::test]
async fn generate_with_options_sets_explicit_owner_id() {
    let handler = make_handler();
    let key = handler
        .generate_with_options(
            "svc-account",
            "internal",
            vec![],
            3600,
            Some("team-a".to_string()),
            Some(100),
        )
        .await
        .unwrap();
    let info = handler.verify(&key).await.unwrap();
    assert_eq!(info.owner_id.as_deref(), Some("team-a"));
    assert_eq!(info.rate_limit, Some(100));
}

/// 启用 allowed_scopes 后,未知 scope 被拒绝。
#[tokio::test]
async fn generate_rejects_disallowed_scope() {
    let handler = make_handler().with_allowed_scopes(vec![
        ApiKeyScope::Read.as_str().to_string(),
        ApiKeyScope::Write.as_str().to_string(),
    ]);
    let ok = handler
        .generate("1001", vec!["read".into(), "write".into()], 3600)
        .await;
    assert!(ok.is_ok(), "允许列表内的 scope 应通过");
    let bad = handler.generate("1001", vec!["delete".into()], 3600).await;
    assert!(
        matches!(bad, Err(GarrisonError::InvalidParam(ref m)) if m.starts_with("apikey-scope-not-allowed::")),
        "未知 scope 应返回 InvalidParam,实际: {:?}",
        bad
    );
}

/// 启用 last_used 追踪后,verify 成功会记录 last_used_at。
#[tokio::test]
#[serial_test::serial]
async fn verify_tracks_last_used_when_enabled() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone())
        .with_last_used_tracking(true)
        .with_allow_global_verify(true);
    let key = handler
        .generate_with_namespace("1001", "internal", vec![], 3600)
        .await
        .unwrap();
    // 初始 last_used_at 为 None
    let info0 = handler.verify(&key).await.unwrap();
    // verify 后应已写入 last_used_at
    let dao_key = format!("garrison:apikey:internal:{}", key_id_of(&key));
    let stored: ApiKeyInfo =
        serde_json::from_str(&dao.get(&dao_key).await.unwrap().unwrap()).unwrap();
    assert!(
        stored.last_used_at.is_some(),
        "启用追踪后 verify 应记录 last_used_at"
    );
    let _ = info0;
}

/// 默认不追踪 last_used(verify 保持只读)。
#[tokio::test]
#[serial_test::serial]
async fn verify_does_not_track_last_used_by_default() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    let key = handler
        .generate_with_namespace("1001", "internal", vec![], 3600)
        .await
        .unwrap();
    handler.verify(&key).await.unwrap();
    let dao_key = format!("garrison:apikey:internal:{}", key_id_of(&key));
    let stored: ApiKeyInfo =
        serde_json::from_str(&dao.get(&dao_key).await.unwrap().unwrap()).unwrap();
    assert!(
        stored.last_used_at.is_none(),
        "默认不应记录 last_used_at(verify 只读)"
    );
}

/// get_keys_older_than 返回从未使用或早于 cutoff 的 key。
#[tokio::test]
#[serial_test::serial]
async fn get_keys_older_than_filters_by_last_used() {
    let dao = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone()).with_allow_global_verify(true);
    // 生成两个 key(均从未使用)
    let _k1 = handler
        .generate_with_namespace("1001", "internal", vec![], 3600)
        .await
        .unwrap();
    let k2 = handler
        .generate_with_namespace("1002", "internal", vec![], 3600)
        .await
        .unwrap();
    // 给 k2 打上一个较新的 last_used
    handler.update_last_used(&k2).await.unwrap();
    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs() as i64;
    // cutoff 取 now:k1 从未使用 → 陈旧;k2 last_used≈now 不 < now → 非陈旧
    let stale = handler.get_keys_older_than("internal", now).await.unwrap();
    assert_eq!(stale.len(), 1, "仅 k1(从未使用)应被视为陈旧");
    assert_eq!(stale[0].login_id, "1001");
}

// max_age 生命周期策略测试

/// 未设置 max_age 时,verify 正常通过(不检查生命周期)。
#[tokio::test]
async fn verify_passes_without_max_age() {
    let handler = make_handler();
    let token = handler.generate("user1", vec![], 3600).await.unwrap();
    let info = handler.verify(&token).await.unwrap();
    assert!(info.created_at > 0, "新生成的 key 应有 created_at");
}

/// 未过期 key(created_at + max_age > now)通过 verify。
#[tokio::test]
async fn verify_passes_with_valid_max_age() {
    let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao)
        .with_max_age(7200)
        .with_allow_global_verify(true); // 2 小时
    let token = handler.generate("user1", vec![], 3600).await.unwrap();
    // key 刚创建,max_age=7200 远未到期
    let info = handler.verify(&token).await.unwrap();
    assert!(info.created_at > 0);
}

/// 超期 key(created_at + max_age < now)被拒绝。
#[tokio::test]
async fn verify_rejects_expired_max_age() {
    let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone())
        .with_max_age(10)
        .with_allow_global_verify(true); // 10 秒
    let token = handler.generate("user1", vec![], 3600).await.unwrap();

    // 手动将 created_at 设为 100 秒前(超过 max_age=10)
    let key_id = key_id_of(&token);
    let dao_key = format!("garrison:apikey:default:{}", key_id);
    let mut info: ApiKeyInfo =
        serde_json::from_str(&dao.get(&dao_key).await.unwrap().unwrap()).unwrap();
    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs() as i64;
    info.created_at = now - 100; // 100 秒前创建,max_age=10,已超期
    dao.set(&dao_key, &serde_json::to_string(&info).unwrap(), 3600)
        .await
        .unwrap();

    let err = handler.verify(&token).await.unwrap_err();
    assert!(
        matches!(err, GarrisonError::ExpiredToken(ref msg) if msg.contains("max-age")),
        "超期 key 应返回 ExpiredToken(max-age),got: {:?}",
        err
    );
}

/// created_at 为必填字段:反序列化缺失该字段的记录直接失败(fail-closed)。
#[test]
fn apikey_info_requires_created_at_field() {
    let json = r#"{"login_id":"1","scopes":[],"expire_at":0,"revoked":false,"namespace":"default","key_id":"a","secret_hash":"b"}"#;
    let result = serde_json::from_str::<ApiKeyInfo>(json);
    assert!(
        result.is_err(),
        "缺失 created_at 的 JSON 应反序列化失败,实际: {:?}",
        result
    );
}

/// 默认构造下无命名空间 `verify()` 被 fail-closed 拒绝;`verify_with_namespace`
/// 不受影响;`with_allow_global_verify(true)` 放开。
#[tokio::test]
async fn global_verify_disabled_by_default() {
    let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
    let handler = ApiKeyHandler::new(dao.clone());
    let key = handler
        .generate_with_namespace("1001", "tenant-a", vec![], 3600)
        .await
        .unwrap();

    // 默认禁用:verify() 返回明确错误
    let err = handler.verify(&key).await.unwrap_err();
    assert!(
        matches!(err, GarrisonError::InvalidParam(ref m) if m.contains("apikey-global-verify-disabled")),
        "默认 verify() 应被禁用,实际: {}",
        err
    );

    // verify_with_namespace 不受影响
    let info = handler
        .verify_with_namespace(&key, "tenant-a")
        .await
        .unwrap();
    assert_eq!(info.namespace, "tenant-a");

    // 显式放开后 verify() 可用
    let relaxed = ApiKeyHandler::new(dao).with_allow_global_verify(true);
    let info = relaxed.verify(&key).await.unwrap();
    assert_eq!(info.namespace, "tenant-a");
}