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

//! Token 模块单元测试:覆盖 `TokenClaims` 序列化、四种风格(uuid / random_64 / simple / jwt)
//! 的 generate / verify / parse 行为与 `TokenStyleFactory` 风格路由。

use super::*;

// TokenClaims 测试

/// TokenClaims 可序列化/反序列化。
#[test]
fn token_claims_serializes() {
    let claims = TokenClaims {
        login_id: "1001".to_string(),
        expire_at: 1700003600,
        device: Some("web".to_string()),
    };
    let json = serde_json::to_string(&claims).unwrap();
    let parsed: TokenClaims = serde_json::from_str(&json).unwrap();
    assert_eq!(parsed.login_id, "1001");
    assert_eq!(parsed.expire_at, 1700003600);
    assert_eq!(parsed.device, Some("web".to_string()));
}

/// TokenClaims device 字段可选。
#[test]
fn token_claims_device_optional() {
    let claims = TokenClaims {
        login_id: "1".to_string(),
        expire_at: 0,
        device: None,
    };
    assert!(claims.device.is_none());
}

// UuidTokenStyle 测试

/// UuidTokenStyle 生成 UUID v4 格式 token。
#[test]
fn uuid_style_generates_uuid_format() {
    let style = UuidTokenStyle;
    let token = style.generate("1001", 3600).unwrap();
    // UUID v4 格式:8-4-4-4-12 十六进制
    assert_eq!(token.len(), 36);
    let parts: Vec<&str> = token.split('-').collect();
    assert_eq!(parts.len(), 5);
    assert_eq!(parts[0].len(), 8);
    assert_eq!(parts[1].len(), 4);
    assert_eq!(parts[2].len(), 4);
    assert_eq!(parts[3].len(), 4);
    assert_eq!(parts[4].len(), 12);
}

/// UuidTokenStyle verify 始终返回 None。
#[test]
fn uuid_style_verify_returns_none() {
    let style = UuidTokenStyle;
    let token = style.generate("1001", 3600).unwrap();
    assert_eq!(style.verify(&token).unwrap(), None);
}

/// UuidTokenStyle parse 返回错误。
#[test]
fn uuid_style_parse_errors() {
    let style = UuidTokenStyle;
    assert!(style.parse("some-token").is_err());
}

// Random64TokenStyle 测试

/// Random64TokenStyle 生成 64 字符随机 hex。
#[test]
fn random64_style_generates_64_hex() {
    let style = Random64TokenStyle;
    let token = style.generate("1001", 3600).unwrap();
    assert_eq!(token.len(), 64);
    assert!(token.chars().all(|c| c.is_ascii_hexdigit()));
}

/// Random64TokenStyle 多次调用返回不同 token。
#[test]
fn random64_style_generates_unique() {
    let style = Random64TokenStyle;
    let t1 = style.generate("1001", 3600).unwrap();
    let t2 = style.generate("1001", 3600).unwrap();
    assert_ne!(t1, t2);
}

/// Random64TokenStyle verify 始终返回 None。
#[test]
fn random64_style_verify_returns_none() {
    let style = Random64TokenStyle;
    assert_eq!(style.verify("abc123").unwrap(), None);
}

// SimpleTokenStyle 测试(HMAC-SHA256 签名版;需 `secure-simple-token` feature,未启用时
// generate 返回 Err(fail-closed))。

/// 测试用 HMAC 密钥(生产环境应从配置注入)。
#[cfg(feature = "secure-simple-token")]
const TEST_SECRET: &str = "test-hmac-secret-key-for-unit-tests-01";

/// 创建带 TEST_SECRET 的 SimpleTokenStyle 实例。
#[cfg(feature = "secure-simple-token")]
fn make_simple_style() -> SimpleTokenStyle {
    SimpleTokenStyle::new(TEST_SECRET.to_string())
}

/// secret 短于 32 字节时 generate/verify/parse 失败(对齐 JWT 双向强校验),32 字节边界成功。
#[cfg(feature = "secure-simple-token")]
#[test]
fn simple_style_secret_31_bytes_fails_32_bytes_succeeds() {
    let short = "a".repeat(31);
    let style_short = SimpleTokenStyle::new(short);
    assert!(
        style_short.generate("u1", 3600).is_err(),
        "31 字节 secret 应拒绝生成 token"
    );
    assert!(
        style_short.verify("x.y").unwrap().is_none(),
        "31 字节 secret verify 应拒绝所有 token"
    );

    let ok = "a".repeat(32);
    let style_ok = SimpleTokenStyle::new(ok);
    assert!(
        style_ok.generate("u1", 3600).is_ok(),
        "32 字节 secret 应成功生成 token"
    );
    assert!(
        style_short.parse("u1\x1fx.y").is_err(),
        "31 字节 secret parse 应拒绝"
    );
}

/// 生成的 token 以 `<login_id>\x1f` 开头并含 UUID 段与 HMAC 段。
#[cfg(feature = "secure-simple-token")]
#[test]
fn simple_style_generates_login_id_prefix() {
    let style = make_simple_style();
    let token = style.generate("1001", 3600).unwrap();
    assert!(
        token.starts_with("1001\x1f"),
        "token 应以 login_id + \\x1f 开头,实际: {}",
        token
    );
    assert!(
        token.contains('.'),
        "token 应含 '.' 分隔 HMAC,实际: {}",
        token
    );
    let after_login = &token["1001\x1f".len()..];
    let uuid_part = after_login.split('.').next().expect("应有 '.' 分隔");
    assert!(
        uuid::Uuid::parse_str(uuid_part).is_ok(),
        "UUID 部分应合法,实际: {}",
        uuid_part
    );
}

/// SimpleTokenStyle verify 解析 login_id(HMAC 校验通过)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn simple_style_verify_extracts_login_id() {
    let style = make_simple_style();
    let token = style.generate("2002", 3600).unwrap();
    let login_id = style.verify(&token).unwrap();
    assert_eq!(login_id, Some("2002".to_string()));
}

/// SimpleTokenStyle parse 返回 TokenClaims(HMAC 校验通过)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn simple_style_parse_returns_claims() {
    let style = make_simple_style();
    let token = style.generate("3003", 3600).unwrap();
    let claims = style.parse(&token).unwrap();
    assert_eq!(claims.login_id, "3003");
}

/// SimpleTokenStyle parse 非数字 login_id 返回 Ok(String 类型不再要求数字)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn simple_style_parse_non_numeric_login_id_returns_ok() {
    let style = make_simple_style();
    let token = style.generate("admin", 3600).unwrap();
    let result = style.parse(&token);
    assert!(result.is_ok());
    let claims = result.unwrap();
    assert_eq!(claims.login_id, "admin");
}

/// SimpleTokenStyle parse 无分隔符返回 Err。
#[cfg(feature = "secure-simple-token")]
#[test]
fn simple_style_parse_no_separator_errors() {
    let style = make_simple_style();
    assert!(style.parse("noseparator").is_err());
}

/// verify 拒绝 UUID 部分无效的伪造 token。
#[cfg(feature = "secure-simple-token")]
#[test]
fn simple_style_verify_rejects_invalid_uuid_suffix() {
    let style = make_simple_style();
    // 伪造 token:UUID 部分不是合法 UUID 格式 + 伪造 HMAC
    let forged = "admin\x1fnot-a-valid-uuid.fakeHmac";
    let result = style.verify(forged).unwrap();
    assert_eq!(result, None, "UUID 部分无效的伪造 token 应返回 None");
}

/// verify 拒绝任意字符串后缀的伪造 token。
#[cfg(feature = "secure-simple-token")]
#[test]
fn simple_style_verify_rejects_arbitrary_string_suffix() {
    let style = make_simple_style();
    let forged = "admin-anything";
    let result = style.verify(forged).unwrap();
    assert_eq!(result, None, "无 HMAC 的伪造 token 应返回 None");
}

/// parse 拒绝 UUID 部分无效的伪造 token。
#[cfg(feature = "secure-simple-token")]
#[test]
fn simple_style_parse_rejects_invalid_uuid_suffix() {
    let style = make_simple_style();
    let forged = "admin\x1ffake-uuid-string.fakeHmac";
    let result = style.parse(forged);
    assert!(result.is_err(), "UUID 部分无效的 token parse 应返回 Err");
}

/// verify 拒绝无 HMAC 的降级 token(攻击者构造 `<login_id>-<uuid>` 绕过 HMAC 校验)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn a11_simple_style_verify_rejects_unsigned_token_without_hmac() {
    let style = make_simple_style();
    let unsigned_token = "root-550e8400-e29b-41d4-a716-446655440000";
    let result = style.verify(unsigned_token).unwrap();
    assert_eq!(result, None, "A11: 无 HMAC 的 token 应被拒绝,防止降级攻击");
}

/// verify 拒绝 HMAC 不匹配的伪造 token(知道格式但不知 secret,构造 fake_hmac 冒充)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn a11_simple_style_verify_rejects_forged_hmac() {
    let style = make_simple_style();
    let forged = "admin\x1f550e8400-e29b-41d4-a716-446655440000.fake-hmac-value";
    let result = style.verify(forged).unwrap();
    assert_eq!(result, None, "A11: HMAC 不匹配的伪造 token 应被拒绝");
}

/// 不同 secret 生成的 token 互不兼容(攻击者用自己的 secret 签发无法通过验证)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn a11_simple_style_verify_rejects_token_from_different_secret() {
    let style_a = SimpleTokenStyle::new("secret-A-0123456789abcdefghijklmnop".to_string());
    let style_b = SimpleTokenStyle::new("secret-B-0123456789abcdefghijklmnop".to_string());
    let token = style_a.generate("victim", 3600).unwrap();
    let result = style_b.verify(&token).unwrap();
    assert_eq!(result, None, "A11: 不同 secret 生成的 token 不应通过验证");
}

/// 空 secret 时 generate 返回 Err(fail-closed)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn a11_simple_style_empty_secret_generate_errors() {
    let style = SimpleTokenStyle::default(); // secret = ""
    let result = style.generate("user", 3600);
    assert!(
        matches!(result, Err(GarrisonError::Config(_))),
        "A11: 空 secret 应返回 Config 错误(fail-closed),实际: {:?}",
        result
    );
}

/// 空 secret 时 verify 返回 None(fail-closed)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn a11_simple_style_empty_secret_verify_returns_none() {
    let style = SimpleTokenStyle::default(); // secret = ""
    let result = style.verify("any-token").unwrap();
    assert_eq!(
        result, None,
        "A11: 空 secret 时所有 token 应视为无效(fail-closed)"
    );
}

/// generate + verify + parse 往返一致:login_id 可含任意字符(除 `\x1f`,边界用例见下方),
/// `expire_at` 为正数(Simple token 现携带 exp)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn a11_simple_style_roundtrip() {
    let style = make_simple_style();
    let token = style.generate("roundtrip_user", 3600).unwrap();
    assert_eq!(
        style.verify(&token).unwrap(),
        Some("roundtrip_user".to_string())
    );
    let claims = style.parse(&token).unwrap();
    assert_eq!(claims.login_id, "roundtrip_user");
    assert!(
        claims.expire_at > chrono::Utc::now().timestamp(),
        "issue 2425/3256: expire_at 应为未来的过期时间戳,实际: {}",
        claims.expire_at
    );
    assert_eq!(claims.device, None);
}

/// parse 拒绝 HMAC 不匹配的 token。
#[cfg(feature = "secure-simple-token")]
#[test]
fn a11_simple_style_parse_rejects_forged_hmac() {
    let style = make_simple_style();
    // 合法 UUID + 合法形态 exp 段 + 伪造 HMAC(命中 HMAC 校验路径)。
    let forged = "admin\x1f550e8400-e29b-41d4-a716-446655440000.9999999999.fake-hmac";
    let result = style.parse(forged);
    assert!(
        matches!(result, Err(GarrisonError::InvalidToken(_))),
        "A11: HMAC 不匹配的 token parse 应返回 InvalidToken,实际: {:?}",
        result
    );
}

// SimpleTokenStyle 支持含 `-` 的 login_id(原格式按 `-` 分割会误吞 UUID 段,已改 `\x1f` 分隔)。

/// email 形式 login_id(含 `-`)往返一致:原按 `split_once('-')` 分割会误吞 UUID 段,
/// 改用 `\x1f` 分隔后可含任意 `-`。
#[cfg(feature = "secure-simple-token")]
#[test]
fn h2_simple_style_supports_dashed_login_id_email() {
    let style = make_simple_style();
    let login_id = "user-1@example.com";
    let token = style.generate(login_id, 3600).unwrap();
    assert!(
        token.starts_with(&format!("{}\x1f", login_id)),
        "token 应以 login_id + \\x1f 开头,实际: {}",
        token
    );
    // verify 返回完整 login_id
    assert_eq!(
        style.verify(&token).unwrap(),
        Some(login_id.to_string()),
        "verify 应返回完整 login_id(含 `-`),实际 token: {}",
        token
    );
    let claims = style.parse(&token).unwrap();
    assert_eq!(
        claims.login_id, login_id,
        "parse 应返回完整 login_id(含 `-`)"
    );
}

/// login_id 为 UUID 形式(含 4 个 `-`)往返一致(原 `-` 分割会截断 login_id)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn h2_simple_style_supports_uuid_login_id() {
    let style = make_simple_style();
    let login_id = "550e8400-e29b-41d4-a716-446655440000";
    let token = style.generate(login_id, 3600).unwrap();
    assert_eq!(
        style.verify(&token).unwrap(),
        Some(login_id.to_string()),
        "verify 应返回完整 UUID 形式 login_id,实际 token: {}",
        token
    );
    let claims = style.parse(&token).unwrap();
    assert_eq!(
        claims.login_id, login_id,
        "parse 应返回完整 UUID 形式 login_id"
    );
}

/// login_id 含多个连续 `-`(kebab-case)时往返一致。
#[cfg(feature = "secure-simple-token")]
#[test]
fn h2_simple_style_supports_kebab_case_login_id() {
    let style = make_simple_style();
    let login_id = "service-account-admin";
    let token = style.generate(login_id, 3600).unwrap();
    assert_eq!(
        style.verify(&token).unwrap(),
        Some(login_id.to_string()),
        "verify 应返回完整 kebab-case login_id,实际 token: {}",
        token
    );
    let claims = style.parse(&token).unwrap();
    assert_eq!(claims.login_id, login_id);
}

/// 未启用 secure-simple-token feature 时 generate 返回 Err。
#[cfg(not(feature = "secure-simple-token"))]
#[test]
fn a11_simple_style_without_feature_generate_errors() {
    let style = SimpleTokenStyle::new("secret".to_string());
    let result = style.generate("user", 3600);
    assert!(
        matches!(result, Err(GarrisonError::Config(_))),
        "A11: 未启用 secure-simple-token feature 时 generate 应返回 Config 错误"
    );
}

// 边界用例:\x1f 分隔符、空 login_id、过期语义

/// login_id 含 `\x1f`(与分隔符同字节)必须拒绝:否则 verify 会切出错误身份;generate
/// fail-closed 拒绝,手工拼接的内嵌 `\x1f` token 也 verify 失败。
#[cfg(feature = "secure-simple-token")]
#[test]
fn boundary_login_id_containing_unit_separator_rejected() {
    let style = make_simple_style();
    let result = style.generate("user\x1fadmin", 3600);
    assert!(
        matches!(result, Err(GarrisonError::InvalidParam(_))),
        "含 \\x1f 的 login_id 应在 generate 时被拒绝,实际: {:?}",
        result
    );

    // 防御:手工构造内嵌 \x1f 前缀的合法 token(u1 的真实签名)也应 verify 失败
    let token = style.generate("u1", 3600).unwrap();
    let poisoned = format!("user\x1f{}", token);
    let verified = style.verify(&poisoned).unwrap();
    assert_eq!(
        verified, None,
        "内嵌 \\x1f 的拼接 token 应被 verify 拒绝(身份混淆防御)"
    );
}

/// 空 login_id 在 generate 时被拒绝(fail-closed,杜绝空身份 token)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn boundary_empty_login_id_rejected_at_generate() {
    let style = make_simple_style();
    let result = style.generate("", 3600);
    assert!(
        matches!(result, Err(GarrisonError::InvalidParam(_))),
        "空 login_id 应返回 InvalidParam(身份旁路防御),实际: {:?}",
        result
    );
    // 防御:verify/parse 对空身份段的手工 token 也应拒绝
    let style_ok = make_simple_style();
    let token = style_ok.generate("u1", 3600).unwrap();
    // 把真实 login_id 段挖空:"\x1f<uuid>.<exp>.<hmac>"(HMAC 必不匹配,先应被空身份检查拒绝)
    let body = token.rsplit_once('.').map(|(b, _)| b).unwrap_or("");
    let hmac = token.rsplit_once('.').map(|(_, h)| h).unwrap_or("");
    let rest = body.split_once('\x1f').map(|(_, r)| r).unwrap_or("");
    let hollowed = format!("\x1f{}.{}", rest, hmac);
    assert_eq!(
        style_ok.verify(&hollowed).unwrap(),
        None,
        "空 login_id 段的 token 应被 verify 拒绝"
    );
}

/// generate 拒绝 timeout <= 0(无过期时间的永久 token 不允许生成)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn boundary_simple_token_rejects_non_positive_timeout() {
    let style = make_simple_style();
    assert!(
        matches!(style.generate("u1", 0), Err(GarrisonError::InvalidParam(_))),
        "timeout=0 应被拒绝,实际: {:?}",
        style.generate("u1", 0)
    );
    assert!(
        matches!(
            style.generate("u1", -3600),
            Err(GarrisonError::InvalidParam(_))
        ),
        "负 timeout 应被拒绝(issue 2408 同源:负值不得回绕),实际: {:?}",
        style.generate("u1", -3600)
    );
}

// TokenStyleFactory 测试

/// Factory 返回 UuidTokenStyle。
#[test]
fn factory_creates_uuid_style() {
    let token = TokenStyleFactory::new("uuid", "secret").unwrap();
    let t = token.generate("1", 60).unwrap();
    assert_eq!(t.len(), 36);
}

/// Factory 返回 Random64TokenStyle。
#[test]
fn factory_creates_random64_style() {
    let token = TokenStyleFactory::new("random_64", "secret").unwrap();
    let t = token.generate("1", 60).unwrap();
    assert_eq!(t.len(), 64);
}

/// Factory 返回 SimpleTokenStyle(传入 secret 用于 HMAC)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn factory_creates_simple_style() {
    let token = TokenStyleFactory::new("simple", "factory-secret-key-0123456789abcd").unwrap();
    let t = token.generate("42", 60).unwrap();
    assert!(t.starts_with("42\x1f"), "token 应以 login_id + \\x1f 开头");
    assert!(t.contains('.'), "token 应含 '.' 分隔 HMAC");
}

/// Factory 返回 SimpleTokenStyle(未启用 feature 时 generate 返回 Err)。
#[cfg(not(feature = "secure-simple-token"))]
#[test]
fn factory_creates_simple_style() {
    let token = TokenStyleFactory::new("simple", "factory-secret").unwrap();
    let result = token.generate("42", 60);
    assert!(
        matches!(result, Err(GarrisonError::Config(_))),
        "A11: 未启用 feature 时 generate 应返回 Config 错误"
    );
}

/// Factory 未知风格返回 Config 错误。
#[test]
fn factory_rejects_unknown_style() {
    let result = TokenStyleFactory::new("unknown", "secret");
    assert!(result.is_err());
    match result.err() {
        Some(GarrisonError::Config(msg)) => assert!(msg.contains("config-unknown-token-style")),
        other => panic!("期望 Config 错误,实际: {:?}", other),
    }
}

/// Factory jwt 风格在无 protocol-jwt feature 时返回错误。
#[cfg(not(feature = "protocol-jwt"))]
#[test]
fn factory_jwt_without_feature_errors() {
    let result = TokenStyleFactory::new("jwt", "secret");
    assert!(result.is_err());
}

/// Factory jwt 风格在有 protocol-jwt feature 时成功创建。
#[cfg(feature = "protocol-jwt")]
#[test]
fn factory_creates_jwt_style() {
    let token = TokenStyleFactory::new("jwt", "secret");
    assert!(token.is_ok());
}

// 覆盖率补充测试(Random64TokenStyle::parse / SimpleTokenStyle::verify 边界)

/// Random64TokenStyle::parse 返回 Err(无 payload)。
#[test]
fn random64_style_parse_errors() {
    let style = Random64TokenStyle;
    let result = style.parse("any-token");
    assert!(result.is_err());
    match result.err() {
        Some(GarrisonError::Internal(msg)) => {
            assert!(msg.contains("random_64"), "应提示 random_64 不支持 parse")
        },
        other => panic!("期望 Internal 错误,实际: {:?}", other),
    }
}

/// SimpleTokenStyle::verify 无分隔符时返回 Ok(None)(无 '.' 视为无效)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn simple_style_verify_no_separator_returns_none() {
    let style = make_simple_style();
    let result = style.verify("noseparator").unwrap();
    assert_eq!(result, None, "无 '.' 分隔符的 token verify 应返回 None");
}

/// SimpleTokenStyle::verify 非数字 login_id 返回 Ok(需合法 HMAC)。
#[cfg(feature = "secure-simple-token")]
#[test]
fn simple_style_verify_non_numeric_returns_ok() {
    let style = make_simple_style();
    let token = style.generate("abc", 3600).unwrap();
    let result = style.verify(&token);
    assert!(result.is_ok(), "verify 应返回 Ok,实际: {:?}", result);
    assert_eq!(result.unwrap(), Some("abc".to_string()));
}

// JwtTokenStyle 覆盖率补充测试(feature-gated)

/// JwtTokenStyle generate + verify 往返测试。
#[cfg(feature = "protocol-jwt")]
#[test]
fn jwt_style_generate_and_verify_roundtrip() {
    let style = JwtTokenStyle::new("test-secret-key-aaaabbbbccccdddd");
    let token = style.generate("1001", 3600).unwrap();
    let login_id = style.verify(&token).unwrap();
    assert_eq!(
        login_id,
        Some("1001".to_string()),
        "JWT verify 应返回 generate 时的 login_id"
    );
}

/// JwtTokenStyle::verify 无效 token 返回 Ok(None)。
#[cfg(feature = "protocol-jwt")]
#[test]
fn jwt_style_verify_invalid_returns_none() {
    let style = JwtTokenStyle::new("test-secret-key-aaaabbbbccccdddd");
    // 篡改的 token(无法通过签名校验)
    let result = style.verify("invalid.jwt.token").unwrap();
    assert_eq!(result, None, "无效 JWT verify 应返回 Ok(None)");
}

/// JwtTokenStyle::parse 有效 token 返回 TokenClaims。
#[cfg(feature = "protocol-jwt")]
#[test]
fn jwt_style_parse_valid_returns_claims() {
    let style = JwtTokenStyle::new("test-secret-key-aaaabbbbccccdddd");
    let token = style.generate("2002", 3600).unwrap();
    let claims = style.parse(&token).unwrap();
    assert_eq!(claims.login_id, "2002");
    assert!(claims.expire_at > 0, "JWT parse 应返回非零过期时间");
}

/// JwtTokenStyle::parse 无效 token 返回 Err。
#[cfg(feature = "protocol-jwt")]
#[test]
fn jwt_style_parse_invalid_returns_error() {
    let style = JwtTokenStyle::new("test-secret-key-aaaabbbbccccdddd");
    let result = style.parse("invalid.jwt.token");
    assert!(result.is_err(), "无效 JWT parse 应返回 Err");
}