use super::*;
#[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()));
}
#[test]
fn token_claims_device_optional() {
let claims = TokenClaims {
login_id: "1".to_string(),
expire_at: 0,
device: None,
};
assert!(claims.device.is_none());
}
#[test]
fn uuid_style_generates_uuid_format() {
let style = UuidTokenStyle;
let token = style.generate("1001", 3600).unwrap();
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);
}
#[test]
fn uuid_style_verify_returns_none() {
let style = UuidTokenStyle;
let token = style.generate("1001", 3600).unwrap();
assert_eq!(style.verify(&token).unwrap(), None);
}
#[test]
fn uuid_style_parse_errors() {
let style = UuidTokenStyle;
assert!(style.parse("some-token").is_err());
}
#[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()));
}
#[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);
}
#[test]
fn random64_style_verify_returns_none() {
let style = Random64TokenStyle;
assert_eq!(style.verify("abc123").unwrap(), None);
}
#[cfg(feature = "secure-simple-token")]
const TEST_SECRET: &str = "test-hmac-secret-key-for-unit-tests-01";
#[cfg(feature = "secure-simple-token")]
fn make_simple_style() -> SimpleTokenStyle {
SimpleTokenStyle::new(TEST_SECRET.to_string())
}
#[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 应拒绝"
);
}
#[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
);
}
#[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()));
}
#[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");
}
#[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");
}
#[cfg(feature = "secure-simple-token")]
#[test]
fn simple_style_parse_no_separator_errors() {
let style = make_simple_style();
assert!(style.parse("noseparator").is_err());
}
#[cfg(feature = "secure-simple-token")]
#[test]
fn simple_style_verify_rejects_invalid_uuid_suffix() {
let style = make_simple_style();
let forged = "admin\x1fnot-a-valid-uuid.fakeHmac";
let result = style.verify(forged).unwrap();
assert_eq!(result, None, "UUID 部分无效的伪造 token 应返回 None");
}
#[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");
}
#[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");
}
#[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 应被拒绝,防止降级攻击");
}
#[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 应被拒绝");
}
#[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 不应通过验证");
}
#[cfg(feature = "secure-simple-token")]
#[test]
fn a11_simple_style_empty_secret_generate_errors() {
let style = SimpleTokenStyle::default(); let result = style.generate("user", 3600);
assert!(
matches!(result, Err(GarrisonError::Config(_))),
"A11: 空 secret 应返回 Config 错误(fail-closed),实际: {:?}",
result
);
}
#[cfg(feature = "secure-simple-token")]
#[test]
fn a11_simple_style_empty_secret_verify_returns_none() {
let style = SimpleTokenStyle::default(); let result = style.verify("any-token").unwrap();
assert_eq!(
result, None,
"A11: 空 secret 时所有 token 应视为无效(fail-closed)"
);
}
#[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);
}
#[cfg(feature = "secure-simple-token")]
#[test]
fn a11_simple_style_parse_rejects_forged_hmac() {
let style = make_simple_style();
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
);
}
#[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
);
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(含 `-`)"
);
}
#[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"
);
}
#[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);
}
#[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 错误"
);
}
#[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
);
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 拒绝(身份混淆防御)"
);
}
#[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
);
let style_ok = make_simple_style();
let token = style_ok.generate("u1", 3600).unwrap();
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 拒绝"
);
}
#[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)
);
}
#[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);
}
#[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);
}
#[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");
}
#[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 错误"
);
}
#[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),
}
}
#[cfg(not(feature = "protocol-jwt"))]
#[test]
fn factory_jwt_without_feature_errors() {
let result = TokenStyleFactory::new("jwt", "secret");
assert!(result.is_err());
}
#[cfg(feature = "protocol-jwt")]
#[test]
fn factory_creates_jwt_style() {
let token = TokenStyleFactory::new("jwt", "secret");
assert!(token.is_ok());
}
#[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),
}
}
#[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");
}
#[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()));
}
#[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"
);
}
#[cfg(feature = "protocol-jwt")]
#[test]
fn jwt_style_verify_invalid_returns_none() {
let style = JwtTokenStyle::new("test-secret-key-aaaabbbbccccdddd");
let result = style.verify("invalid.jwt.token").unwrap();
assert_eq!(result, None, "无效 JWT verify 应返回 Ok(None)");
}
#[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 应返回非零过期时间");
}
#[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");
}