use crate::error::BaseError;
#[cfg(feature = "validator")]
use crate::table::RegexCache;
use crate::table::Validator;
use serde_json::json;
use std::sync::Arc;
#[test]
fn test_validator_display_name() {
assert_eq!(Validator::MinLength(5).display_name(), "最小长度");
assert_eq!(Validator::MaxLength(10).display_name(), "最大长度");
assert_eq!(Validator::Min(0.0).display_name(), "最小值");
assert_eq!(Validator::Max(100.0).display_name(), "最大值");
assert_eq!(Validator::Email.display_name(), "邮箱格式(严格)");
assert_eq!(Validator::Phone.display_name(), "手机号格式(严格)");
assert_eq!(Validator::Url.display_name(), "URL格式");
assert_eq!(
Validator::Regex(r"^\d+$".to_string()).display_name(),
"正则表达式"
);
let custom_validator = Validator::Custom(Arc::new(|_, _| Ok(())));
assert_eq!(custom_validator.display_name(), "自定义验证");
}
#[test]
fn test_min_length_success() {
let validator = Validator::MinLength(5);
assert!(validator.validate("username", &json!("alice")).is_ok());
assert!(validator.validate("username", &json!("hello")).is_ok());
assert!(validator.validate("username", &json!("12345")).is_ok());
assert!(validator
.validate("username", &json!("very long username"))
.is_ok());
}
#[test]
fn test_min_length_too_short() {
let validator = Validator::MinLength(5);
let result = validator.validate("username", &json!("bob"));
assert!(result.is_err());
if let Err(BaseError::ValidationFailed(field, msg)) = result {
assert_eq!(field, "username");
assert!(msg.contains("字符串长度不能小于 5"));
assert!(msg.contains("当前长度: 3"));
} else {
panic!("期望 ValidationFailed 错误");
}
}
#[test]
fn test_min_length_empty_string() {
let validator = Validator::MinLength(1);
let result = validator.validate("username", &json!(""));
assert!(result.is_err());
}
#[test]
fn test_min_length_invalid_type() {
let validator = Validator::MinLength(5);
assert!(validator.validate("username", &json!(123)).is_err());
assert!(validator.validate("username", &json!(true)).is_err());
assert!(validator.validate("username", &json!(null)).is_err());
}
#[test]
fn test_max_length_success() {
let validator = Validator::MaxLength(10);
assert!(validator.validate("name", &json!("short")).is_ok());
assert!(validator.validate("name", &json!("")).is_ok());
assert!(validator.validate("name", &json!("1234567890")).is_ok());
}
#[test]
fn test_max_length_too_long() {
let validator = Validator::MaxLength(10);
let result = validator.validate("name", &json!("this is too long"));
assert!(result.is_err());
if let Err(BaseError::ValidationFailed(field, msg)) = result {
assert_eq!(field, "name");
assert!(msg.contains("字符串长度不能大于 10"));
assert!(msg.contains("当前长度: 16"));
} else {
panic!("期望 ValidationFailed 错误");
}
}
#[test]
fn test_max_length_invalid_type() {
let validator = Validator::MaxLength(10);
assert!(validator.validate("name", &json!(123)).is_err());
assert!(validator.validate("name", &json!(true)).is_err());
}
#[test]
fn test_min_value_success() {
let validator = Validator::Min(0.0);
assert!(validator.validate("age", &json!(18)).is_ok());
assert!(validator.validate("age", &json!(100)).is_ok());
assert!(validator.validate("age", &json!(0)).is_ok());
assert!(validator.validate("age", &json!(0.0)).is_ok());
assert!(validator.validate("price", &json!(9.99)).is_ok());
}
#[test]
fn test_min_value_too_small() {
let validator = Validator::Min(0.0);
let result = validator.validate("age", &json!(-5));
assert!(result.is_err());
if let Err(BaseError::ValidationFailed(field, msg)) = result {
assert_eq!(field, "age");
assert!(msg.contains("数值不能小于 0"));
assert!(msg.contains("当前值: -5"));
} else {
panic!("期望 ValidationFailed 错误");
}
}
#[test]
fn test_min_value_invalid_type() {
let validator = Validator::Min(0.0);
assert!(validator.validate("age", &json!("not a number")).is_err());
assert!(validator.validate("age", &json!(true)).is_err());
}
#[test]
fn test_min_and_max_tolerate_decimal_strings() {
let min = Validator::Min(0.0);
assert!(min.validate("price", &json!("9.99")).is_ok());
assert!(min.validate("price", &json!("0")).is_ok());
assert!(min.validate("price", &json!("-1")).is_err());
assert!(min.validate("price", &json!("-0.5")).is_err());
assert!(min.validate("price", &json!("not a number")).is_err());
let max = Validator::Max(100.0);
assert!(max.validate("price", &json!("99.99")).is_ok());
assert!(max.validate("price", &json!("100")).is_ok());
assert!(max.validate("price", &json!("100.5")).is_err());
}
#[test]
fn test_max_value_success() {
let validator = Validator::Max(100.0);
assert!(validator.validate("score", &json!(95)).is_ok());
assert!(validator.validate("score", &json!(0)).is_ok());
assert!(validator.validate("score", &json!(100)).is_ok());
assert!(validator.validate("score", &json!(100.0)).is_ok());
assert!(validator.validate("score", &json!(-50)).is_ok());
}
#[test]
fn test_max_value_too_large() {
let validator = Validator::Max(100.0);
let result = validator.validate("score", &json!(150));
assert!(result.is_err());
if let Err(BaseError::ValidationFailed(field, msg)) = result {
assert_eq!(field, "score");
assert!(msg.contains("数值不能大于 100"));
assert!(msg.contains("当前值: 150"));
} else {
panic!("期望 ValidationFailed 错误");
}
}
#[test]
fn test_max_value_invalid_type() {
let validator = Validator::Max(100.0);
assert!(validator.validate("score", &json!("not a number")).is_err());
assert!(validator.validate("score", &json!(true)).is_err());
}
#[test]
fn test_email_success() {
let validator = Validator::Email;
assert!(validator
.validate("email", &json!("user@example.com"))
.is_ok());
assert!(validator.validate("email", &json!("test@test.org")).is_ok());
assert!(validator.validate("email", &json!("a@b.cn")).is_ok());
}
#[test]
#[cfg(feature = "validator")]
fn test_email_invalid_format() {
let validator = Validator::Email;
let result = validator.validate("email", &json!("invalid"));
assert!(result.is_err());
if let Err(BaseError::ValidationFailed(field, msg)) = result {
assert_eq!(field, "email");
assert!(msg.contains("邮箱格式无效"));
} else {
panic!("期望 ValidationFailed 错误");
}
assert!(validator.validate("email", &json!("")).is_err());
assert!(validator.validate("email", &json!("user@example")).is_err());
}
#[test]
fn test_email_invalid_type() {
let validator = Validator::Email;
assert!(validator.validate("email", &json!(123)).is_err());
assert!(validator.validate("email", &json!(true)).is_err());
}
#[test]
fn test_phone_success() {
let validator = Validator::Phone;
assert!(validator.validate("phone", &json!("13800138000")).is_ok());
assert!(validator
.validate("phone", &json!("+8613800138000"))
.is_ok());
assert!(validator.validate("phone", &json!("1234567890")).is_ok());
}
#[test]
#[cfg(feature = "validator")]
fn test_phone_invalid_format() {
let validator = Validator::Phone;
let result = validator.validate("phone", &json!("138abc"));
assert!(result.is_err());
if let Err(BaseError::ValidationFailed(field, msg)) = result {
assert_eq!(field, "phone");
assert!(msg.contains("手机号格式无效"));
} else {
panic!("期望 ValidationFailed 错误");
}
assert!(validator.validate("phone", &json!("138 0013")).is_err());
assert!(validator.validate("phone", &json!("0138001380")).is_err());
}
#[test]
fn test_phone_invalid_type() {
let validator = Validator::Phone;
assert!(validator.validate("phone", &json!(123)).is_err());
assert!(validator.validate("phone", &json!(true)).is_err());
}
#[test]
fn test_url_success() {
let validator = Validator::Url;
assert!(validator
.validate("website", &json!("https://example.com"))
.is_ok());
assert!(validator
.validate("website", &json!("http://example.com"))
.is_ok());
assert!(validator
.validate("website", &json!("https://www.example.com/path?query=1"))
.is_ok());
}
#[test]
fn test_url_invalid_format() {
let validator = Validator::Url;
let result = validator.validate("website", &json!("example.com"));
assert!(result.is_err());
if let Err(BaseError::ValidationFailed(field, msg)) = result {
assert_eq!(field, "website");
assert!(msg.contains("URL 格式无效"));
assert!(msg.contains("必须以 http:// 或 https:// 开头"));
} else {
panic!("期望 ValidationFailed 错误");
}
assert!(validator
.validate("website", &json!("ftp://example.com"))
.is_err());
assert!(validator.validate("website", &json!("invalid")).is_err());
}
#[test]
fn test_url_invalid_type() {
let validator = Validator::Url;
assert!(validator.validate("website", &json!(123)).is_err());
assert!(validator.validate("website", &json!(true)).is_err());
}
#[test]
#[cfg(feature = "validator")]
fn test_regex_success() {
let validator = Validator::Regex(r"^\d{6}$".to_string());
assert!(validator.validate("code", &json!("123456")).is_ok());
assert!(validator.validate("code", &json!("000000")).is_ok());
}
#[test]
#[cfg(feature = "validator")]
fn test_regex_invalid_format() {
let validator = Validator::Regex(r"^\d{6}$".to_string());
let result = validator.validate("code", &json!("12345"));
assert!(result.is_err());
if let Err(BaseError::ValidationFailed(field, msg)) = result {
assert_eq!(field, "code");
assert!(msg.contains("值不匹配正则表达式"));
} else {
panic!("期望 ValidationFailed 错误");
}
assert!(validator.validate("code", &json!("12345a")).is_err());
assert!(validator.validate("code", &json!("1234567")).is_err());
}
#[test]
#[cfg(feature = "validator")]
fn test_regex_invalid_pattern() {
let validator = Validator::Regex(r"[invalid(".to_string());
let result = validator.validate("code", &json!("test"));
assert!(result.is_err());
if let Err(BaseError::ValidationFailed(field, msg)) = result {
assert_eq!(field, "code");
assert!(msg.contains("正则表达式"));
} else {
panic!("期望 ValidationFailed 错误");
}
}
#[test]
fn test_regex_invalid_type() {
let validator = Validator::Regex(r"^\d+$".to_string());
assert!(validator.validate("code", &json!(123)).is_err());
assert!(validator.validate("code", &json!(true)).is_err());
}
#[test]
fn test_custom_validator_success() {
let validator = Validator::Custom(Arc::new(|_field_name, value| {
if let Some(s) = value.as_str() {
if s.len() >= 3 {
return Ok(());
}
}
Err(BaseError::ValidationFailed(
_field_name.to_string(),
"自定义验证失败:长度必须大于等于 3".to_string(),
))
}));
assert!(validator.validate("field", &json!("abc")).is_ok());
assert!(validator.validate("field", &json!("hello")).is_ok());
}
#[test]
fn test_custom_validator_failure() {
let validator = Validator::Custom(Arc::new(|field_name, value| {
if let Some(s) = value.as_str() {
if s.contains("forbidden") {
return Err(BaseError::ValidationFailed(
field_name.to_string(),
"包含禁止的词汇".to_string(),
));
}
}
Ok(())
}));
let result = validator.validate("content", &json!("forbidden word"));
assert!(result.is_err());
if let Err(BaseError::ValidationFailed(field, msg)) = result {
assert_eq!(field, "content");
assert_eq!(msg, "包含禁止的词汇");
} else {
panic!("期望 ValidationFailed 错误");
}
assert!(validator.validate("content", &json!("normal text")).is_ok());
}
#[test]
fn test_validator_serialization() {
let validator = Validator::MinLength(5);
let json = serde_json::to_string(&validator).unwrap();
let deserialized: Validator = serde_json::from_str(&json).unwrap();
assert!(matches!(deserialized, Validator::MinLength(5)));
let validator = Validator::MaxLength(10);
let json = serde_json::to_string(&validator).unwrap();
let deserialized: Validator = serde_json::from_str(&json).unwrap();
assert!(matches!(deserialized, Validator::MaxLength(10)));
let validator = Validator::Min(0.0);
let json = serde_json::to_string(&validator).unwrap();
let deserialized: Validator = serde_json::from_str(&json).unwrap();
assert!(matches!(deserialized, Validator::Min(v) if (v - 0.0).abs() < f64::EPSILON));
let validator = Validator::Max(100.0);
let json = serde_json::to_string(&validator).unwrap();
let deserialized: Validator = serde_json::from_str(&json).unwrap();
assert!(matches!(deserialized, Validator::Max(v) if (v - 100.0).abs() < f64::EPSILON));
let validator = Validator::Email;
let json = serde_json::to_string(&validator).unwrap();
let deserialized: Validator = serde_json::from_str(&json).unwrap();
assert!(matches!(deserialized, Validator::Email));
let validator = Validator::Phone;
let json = serde_json::to_string(&validator).unwrap();
let deserialized: Validator = serde_json::from_str(&json).unwrap();
assert!(matches!(deserialized, Validator::Phone));
let validator = Validator::Url;
let json = serde_json::to_string(&validator).unwrap();
let deserialized: Validator = serde_json::from_str(&json).unwrap();
assert!(matches!(deserialized, Validator::Url));
let validator = Validator::Regex(r"^\d+$".to_string());
let json = serde_json::to_string(&validator).unwrap();
let deserialized: Validator = serde_json::from_str(&json).unwrap();
if let Validator::Regex(pattern) = deserialized {
assert_eq!(pattern, r"^\d+$");
} else {
panic!("期望 Regex 验证器");
}
}
#[cfg(not(feature = "validator"))]
#[test]
fn test_regex_reports_feature_requirement_without_validator() {
let error = match Validator::Regex("^[0-9]+$".to_string()).validate("code", &json!("123")) {
Err(error) => error,
Ok(()) => panic!("未启用 validator 时 Regex 必须 fail-closed"),
};
assert!(error.to_string().contains("需要启用 'validator' feature"));
}
#[cfg(not(feature = "validator"))]
#[test]
fn test_email_and_phone_use_documented_fallback_without_validator() {
assert!(Validator::Email
.validate("email", &json!("user@example"))
.is_ok());
assert!(Validator::Email
.validate("email", &json!("missing-at"))
.is_err());
assert!(Validator::Phone
.validate("phone", &json!("+86-13800138000"))
.is_ok());
assert!(Validator::Phone
.validate("phone", &json!("13800x"))
.is_err());
}
#[test]
fn test_custom_validator_serialization_fails() {
let validator = Validator::Custom(Arc::new(|_, _| Ok(())));
let result = serde_json::to_string(&validator);
assert!(result.is_err());
}
#[test]
fn test_validator_debug() {
assert_eq!(format!("{:?}", Validator::MinLength(5)), "MinLength(5)");
assert_eq!(format!("{:?}", Validator::MaxLength(10)), "MaxLength(10)");
assert_eq!(format!("{:?}", Validator::Min(0.0)), "Min(0)");
assert_eq!(format!("{:?}", Validator::Max(100.0)), "Max(100)");
assert_eq!(format!("{:?}", Validator::Email), "Email");
assert_eq!(format!("{:?}", Validator::Phone), "Phone");
assert_eq!(format!("{:?}", Validator::Url), "Url");
assert_eq!(
format!("{:?}", Validator::Regex(r"^\d+$".to_string())),
"Regex(\"^\\d+$\")"
);
let custom_validator = Validator::Custom(Arc::new(|_, _| Ok(())));
assert_eq!(format!("{:?}", custom_validator), "Custom(<function>)");
}
#[test]
#[cfg(feature = "validator")]
fn regex_cache_is_bounded_by_cap() {
let cache = RegexCache::new(8);
for i in 0..12u32 {
let pattern = format!(r"^bounded_{}$", i);
let _ = Validator::Regex(pattern).validate_with("f", &json!("x"), &cache);
}
assert_eq!(cache.cap(), 8);
assert!(
cache.len() <= 8,
"缓存条目数 {} 应不超过 cap {}",
cache.len(),
cache.cap()
);
assert_eq!(cache.len(), 8, "前 8 个 pattern 应全部入表,之后不再增长");
}
#[test]
#[cfg(feature = "validator")]
fn overlong_pattern_is_not_cached() {
let cache = RegexCache::new(16);
let overlong = format!("^{}$", "a".repeat(600));
let result = Validator::Regex(overlong).validate_with("f", &json!("aaa"), &cache);
assert!(result.is_err(), "超长 pattern 与值不匹配应报验证失败");
assert!(
cache.is_empty(),
"超长 pattern 不应入表,缓存应保持为空,实际 len = {}",
cache.len()
);
}