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";
#[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_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_legacy_token_without_hmac() {
let style = make_simple_style();
let legacy_token = "root-550e8400-e29b-41d4-a716-446655440000";
let result = style.verify(legacy_token).unwrap();
assert_eq!(
result, None,
"A11: 旧格式 token(无 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 应被拒绝");
}
#[cfg(feature = "secure-simple-token")]
#[test]
fn a11_simple_style_verify_rejects_token_from_different_secret() {
let style_a = SimpleTokenStyle::new("secret-A".to_string());
let style_b = SimpleTokenStyle::new("secret-B".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_eq!(claims.expire_at, 0); 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.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 错误"
);
}
#[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").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("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");
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");
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");
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");
let result = style.parse("invalid.jwt.token");
assert!(result.is_err(), "无效 JWT parse 应返回 Err");
}