1#[allow(dead_code)] pub const MYSQL_MAX_VARCHAR_LENGTH: usize = 16_383;
8
9#[allow(dead_code)] pub const POSTGRES_MAX_VARCHAR_LENGTH: usize = 10_485_760;
12
13#[cfg(all(feature = "mysql", not(feature = "postgres")))]
21pub const MAX_VARCHAR_LENGTH: usize = MYSQL_MAX_VARCHAR_LENGTH;
22#[cfg(feature = "postgres")]
24pub const MAX_VARCHAR_LENGTH: usize = POSTGRES_MAX_VARCHAR_LENGTH;
25#[cfg(not(any(feature = "mysql", feature = "postgres")))]
27pub const MAX_VARCHAR_LENGTH: usize = MYSQL_MAX_VARCHAR_LENGTH;
28
29use crate::error::BaseError;
30use serde::{Deserialize, Serialize};
31
32fn value_type_name(value: &serde_json::Value) -> &'static str {
42 match value {
43 serde_json::Value::Null => "null",
44 serde_json::Value::Bool(_) => "boolean",
45 serde_json::Value::Number(_) => "number",
46 serde_json::Value::String(_) => "string",
47 serde_json::Value::Array(_) => "array",
48 serde_json::Value::Object(_) => "object",
49 }
50}
51
52#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
77#[non_exhaustive]
78pub enum FieldType {
79 String {
95 max_length: usize,
97 },
98
99 Integer,
111
112 BigInt,
124
125 Float,
137
138 Double,
150
151 Decimal {
153 precision: u8,
155 scale: u8,
157 },
158
159 Boolean,
171
172 Date,
184
185 DateTime,
197
198 Timestamp,
210
211 Json,
223
224 Text,
236
237 Enum {
259 values: Vec<String>,
261 },
262
263 Uuid,
277
278 Bytes,
291
292 Array(Box<FieldType>),
298}
299
300impl FieldType {
301 pub fn display_name(&self) -> &str {
319 match self {
320 FieldType::String { .. } => "字符串",
321 FieldType::Integer => "整数",
322 FieldType::BigInt => "长整数",
323 FieldType::Float => "单精度浮点数",
324 FieldType::Double => "双精度浮点数",
325 FieldType::Decimal { .. } => "定点小数",
326 FieldType::Boolean => "布尔值",
327 FieldType::Date => "日期",
328 FieldType::DateTime => "日期时间",
329 FieldType::Timestamp => "时间戳",
330 FieldType::Json => "JSON",
331 FieldType::Text => "文本",
332 FieldType::Enum { .. } => "枚举",
333 FieldType::Uuid => "UUID",
334 FieldType::Bytes => "二进制",
335 FieldType::Array(_) => "数组",
336 }
337 }
338
339 pub fn array(element: FieldType) -> Self {
353 FieldType::Array(Box::new(element))
354 }
355
356 pub fn is_uuid(&self) -> bool {
358 matches!(self, FieldType::Uuid)
359 }
360
361 pub fn is_binary(&self) -> bool {
363 matches!(self, FieldType::Bytes)
364 }
365
366 pub fn is_array(&self) -> bool {
368 matches!(self, FieldType::Array(_))
369 }
370
371 pub fn is_numeric(&self) -> bool {
387 matches!(
388 self,
389 FieldType::Integer
390 | FieldType::BigInt
391 | FieldType::Float
392 | FieldType::Double
393 | FieldType::Decimal { .. }
394 )
395 }
396
397 pub fn is_temporal(&self) -> bool {
413 matches!(
414 self,
415 FieldType::Date | FieldType::DateTime | FieldType::Timestamp
416 )
417 }
418
419 pub fn is_text(&self) -> bool {
435 matches!(self, FieldType::String { .. } | FieldType::Text)
436 }
437
438 pub fn validate(&self, field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
464 match self {
465 FieldType::String { max_length } => {
467 if let Some(s) = value.as_str() {
468 let len = s.chars().count();
469 if len > *max_length {
470 return Err(BaseError::StringTooLong(
471 field_name.to_string(),
472 len,
473 *max_length,
474 ));
475 }
476 Ok(())
477 } else {
478 Err(BaseError::InvalidFieldType(
479 field_name.to_string(),
480 format!("期望字符串类型,实际类型: {}", value_type_name(value)),
481 ))
482 }
483 }
484
485 FieldType::Integer => {
487 if value.is_i64() || value.is_u64() {
488 if let Some(n) = value.as_i64() {
490 if n >= i32::MIN as i64 && n <= i32::MAX as i64 {
491 return Ok(());
492 }
493 }
494 Err(BaseError::InvalidFieldType(
495 field_name.to_string(),
496 "整数值超出 i32 范围".to_string(),
497 ))
498 } else {
499 Err(BaseError::InvalidFieldType(
500 field_name.to_string(),
501 format!("期望整数类型,实际类型: {}", value_type_name(value)),
502 ))
503 }
504 }
505
506 FieldType::BigInt => {
508 if value.as_i64().is_some() {
509 Ok(())
510 } else {
511 Err(BaseError::InvalidFieldType(
512 field_name.to_string(),
513 format!("期望 i64 范围内的长整数,实际值: {}", value),
514 ))
515 }
516 }
517
518 FieldType::Float => {
520 if value.is_f64() || value.is_i64() || value.is_u64() {
521 if let Some(n) = value.as_f64() {
523 if n.is_finite() && n.abs() <= f32::MAX as f64 {
524 return Ok(());
525 }
526 }
527 Err(BaseError::InvalidFieldType(
528 field_name.to_string(),
529 "浮点数值超出 f32 范围".to_string(),
530 ))
531 } else {
532 Err(BaseError::InvalidFieldType(
533 field_name.to_string(),
534 format!("期望浮点数类型,实际类型: {}", value_type_name(value)),
535 ))
536 }
537 }
538
539 FieldType::Double => {
541 if value.is_f64() || value.is_i64() || value.is_u64() {
542 Ok(())
543 } else {
544 Err(BaseError::InvalidFieldType(
545 field_name.to_string(),
546 format!("期望双精度浮点数类型,实际类型: {}", value_type_name(value)),
547 ))
548 }
549 }
550
551 FieldType::Decimal { precision, scale } => {
552 validate_decimal(field_name, value, *precision, *scale)
553 }
554
555 FieldType::Boolean => {
557 if value.is_boolean() {
558 Ok(())
559 } else {
560 Err(BaseError::InvalidFieldType(
561 field_name.to_string(),
562 format!("期望布尔类型,实际类型: {}", value_type_name(value)),
563 ))
564 }
565 }
566
567 FieldType::Date => validate_date(field_name, value),
569
570 FieldType::DateTime => validate_datetime(field_name, value),
572
573 FieldType::Timestamp => validate_timestamp(field_name, value),
575
576 FieldType::Enum { values } => {
578 if let Some(s) = value.as_str() {
579 if values.contains(&s.to_string()) {
580 Ok(())
581 } else {
582 Err(BaseError::InvalidEnumValue(
583 field_name.to_string(),
584 s.to_string(),
585 ))
586 }
587 } else {
588 Err(BaseError::InvalidFieldType(
589 field_name.to_string(),
590 format!(
591 "期望字符串类型的枚举值,实际类型: {}",
592 value_type_name(value)
593 ),
594 ))
595 }
596 }
597
598 FieldType::Json => {
600 if value.is_object() || value.is_array() {
601 Ok(())
602 } else {
603 Err(BaseError::InvalidFieldType(
604 field_name.to_string(),
605 format!("期望 JSON 对象或数组,实际类型: {}", value_type_name(value)),
606 ))
607 }
608 }
609
610 FieldType::Text => {
612 if value.as_str().is_some() {
613 Ok(())
614 } else {
615 Err(BaseError::InvalidFieldType(
616 field_name.to_string(),
617 format!("期望文本字符串类型,实际类型: {}", value_type_name(value)),
618 ))
619 }
620 }
621
622 FieldType::Uuid => {
624 if value.as_str().is_some() {
625 Ok(())
626 } else {
627 Err(BaseError::InvalidFieldType(
628 field_name.to_string(),
629 format!("期望 UUID 字符串,实际类型: {}", value_type_name(value)),
630 ))
631 }
632 }
633
634 FieldType::Bytes => {
636 if value.as_str().is_some() {
637 Ok(())
638 } else {
639 Err(BaseError::InvalidFieldType(
640 field_name.to_string(),
641 format!(
642 "期望 Base64 二进制字符串,实际类型: {}",
643 value_type_name(value)
644 ),
645 ))
646 }
647 }
648
649 FieldType::Array(element) => {
651 let Some(items) = value.as_array() else {
652 return Err(BaseError::InvalidFieldType(
653 field_name.to_string(),
654 format!("期望 JSON 数组,实际类型: {}", value_type_name(value)),
655 ));
656 };
657 for item in items {
658 if !item.is_null() {
659 element.validate(field_name, item)?;
660 }
661 }
662 Ok(())
663 }
664 }
665 }
666}
667
668fn validate_decimal(
669 field_name: &str,
670 value: &serde_json::Value,
671 precision: u8,
672 scale: u8,
673) -> Result<(), BaseError> {
674 let text = match value {
675 serde_json::Value::String(value) => std::borrow::Cow::Borrowed(value.as_str()),
676 serde_json::Value::Number(value) => std::borrow::Cow::Owned(value.to_string()),
677 _ => {
678 return Err(BaseError::InvalidFieldType(
679 field_name.to_string(),
680 format!(
681 "期望十进制数字或字符串,实际类型: {}",
682 value_type_name(value)
683 ),
684 ));
685 }
686 };
687 let unsigned = text.strip_prefix('-').unwrap_or(text.as_ref());
688 let (integer, fraction) = unsigned.split_once('.').unwrap_or((unsigned, ""));
689 let digits = integer.len() + fraction.len();
690 let valid = !integer.is_empty()
691 && integer.bytes().all(|byte| byte.is_ascii_digit())
692 && fraction.bytes().all(|byte| byte.is_ascii_digit())
693 && digits <= usize::from(precision)
694 && fraction.len() <= usize::from(scale);
695 if valid {
696 Ok(())
697 } else {
698 Err(BaseError::InvalidFieldType(
699 field_name.to_string(),
700 format!("值 {text} 不符合 DECIMAL({precision}, {scale})"),
701 ))
702 }
703}
704
705fn validate_date(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
706 if let Some(s) = value.as_str() {
707 chrono::NaiveDate::parse_from_str(s, "%Y-%m-%d")
708 .map(|_| ())
709 .map_err(|_| {
710 BaseError::InvalidFieldType(
711 field_name.to_string(),
712 format!("日期格式无效,期望 YYYY-MM-DD,实际: {}", s),
713 )
714 })
715 } else {
716 Err(BaseError::InvalidFieldType(
717 field_name.to_string(),
718 format!("期望日期字符串类型,实际类型: {}", value_type_name(value)),
719 ))
720 }
721}
722
723fn validate_datetime(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
724 if let Some(s) = value.as_str() {
725 chrono::DateTime::parse_from_rfc3339(s)
726 .map(|_| ())
727 .map_err(|_| {
728 BaseError::InvalidFieldType(
729 field_name.to_string(),
730 format!("日期时间格式无效,期望 RFC 3339,实际: {s}"),
731 )
732 })
733 } else {
734 Err(BaseError::InvalidFieldType(
735 field_name.to_string(),
736 format!(
737 "期望日期时间字符串类型,实际类型: {}",
738 value_type_name(value)
739 ),
740 ))
741 }
742}
743
744fn validate_timestamp(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
745 if let Some(ts) = value.as_i64() {
746 chrono::DateTime::<chrono::Utc>::from_timestamp_secs(ts)
747 .map(|_| ())
748 .ok_or_else(|| {
749 BaseError::InvalidFieldType(
750 field_name.to_string(),
751 format!("时间戳超出有效范围,实际: {}", ts),
752 )
753 })
754 } else {
755 Err(BaseError::InvalidFieldType(
756 field_name.to_string(),
757 format!("期望 Unix 时间戳整数,实际类型: {}", value_type_name(value)),
758 ))
759 }
760}
761
762#[cfg(test)]
763mod tests {
764 use super::*;
765
766 #[test]
768 fn varchar_limit_follows_backend_dialect() {
769 assert_eq!(MYSQL_MAX_VARCHAR_LENGTH, 16_383);
770 assert_eq!(POSTGRES_MAX_VARCHAR_LENGTH, 10_485_760);
771
772 #[cfg(all(feature = "mysql", not(feature = "postgres")))]
773 assert_eq!(MAX_VARCHAR_LENGTH, MYSQL_MAX_VARCHAR_LENGTH);
774 #[cfg(feature = "postgres")]
775 assert_eq!(MAX_VARCHAR_LENGTH, POSTGRES_MAX_VARCHAR_LENGTH);
776 #[cfg(not(any(feature = "mysql", feature = "postgres")))]
777 assert_eq!(MAX_VARCHAR_LENGTH, MYSQL_MAX_VARCHAR_LENGTH);
778 }
779
780 #[test]
781 fn test_field_type_display_name() {
782 assert_eq!(
783 FieldType::String { max_length: 50 }.display_name(),
784 "字符串"
785 );
786 assert_eq!(FieldType::Integer.display_name(), "整数");
787 assert_eq!(FieldType::BigInt.display_name(), "长整数");
788 assert_eq!(FieldType::Float.display_name(), "单精度浮点数");
789 assert_eq!(FieldType::Double.display_name(), "双精度浮点数");
790 assert_eq!(FieldType::Boolean.display_name(), "布尔值");
791 assert_eq!(FieldType::Date.display_name(), "日期");
792 assert_eq!(FieldType::DateTime.display_name(), "日期时间");
793 assert_eq!(FieldType::Timestamp.display_name(), "时间戳");
794 assert_eq!(FieldType::Json.display_name(), "JSON");
795 assert_eq!(FieldType::Text.display_name(), "文本");
796 assert_eq!(
797 FieldType::Enum {
798 values: vec!["a".to_string()]
799 }
800 .display_name(),
801 "枚举"
802 );
803 }
804
805 #[test]
806 fn test_is_numeric() {
807 assert!(FieldType::Integer.is_numeric());
808 assert!(FieldType::BigInt.is_numeric());
809 assert!(FieldType::Float.is_numeric());
810 assert!(FieldType::Double.is_numeric());
811 assert!(!FieldType::String { max_length: 50 }.is_numeric());
812 assert!(!FieldType::Boolean.is_numeric());
813 }
814
815 #[test]
816 fn test_is_temporal() {
817 assert!(FieldType::Date.is_temporal());
818 assert!(FieldType::DateTime.is_temporal());
819 assert!(FieldType::Timestamp.is_temporal());
820 assert!(!FieldType::String { max_length: 50 }.is_temporal());
821 assert!(!FieldType::Integer.is_temporal());
822 }
823
824 #[test]
825 fn test_is_text() {
826 assert!(FieldType::String { max_length: 50 }.is_text());
827 assert!(FieldType::Text.is_text());
828 assert!(!FieldType::Integer.is_text());
829 assert!(!FieldType::Boolean.is_text());
830 }
831
832 #[test]
833 fn test_field_type_equality() {
834 let type1 = FieldType::String { max_length: 50 };
835 let type2 = FieldType::String { max_length: 50 };
836 let type3 = FieldType::String { max_length: 100 };
837
838 assert_eq!(type1, type2);
839 assert_ne!(type1, type3);
840 }
841
842 #[test]
843 fn test_enum_type() {
844 let enum_type = FieldType::Enum {
845 values: vec![
846 "pending".to_string(),
847 "approved".to_string(),
848 "rejected".to_string(),
849 ],
850 };
851
852 assert_eq!(enum_type.display_name(), "枚举");
853 assert!(!enum_type.is_numeric());
854 assert!(!enum_type.is_temporal());
855 assert!(!enum_type.is_text());
856 }
857
858 #[test]
861 fn test_validate_string_success() {
862 let field_type = FieldType::String { max_length: 10 };
863
864 assert!(field_type
866 .validate("name", &serde_json::json!("hello"))
867 .is_ok());
868 assert!(field_type.validate("name", &serde_json::json!("")).is_ok());
869
870 assert!(field_type
872 .validate("name", &serde_json::json!("1234567890"))
873 .is_ok());
874 }
875
876 #[test]
877 fn test_validate_string_too_long() {
878 let field_type = FieldType::String { max_length: 10 };
879
880 let result = field_type.validate("name", &serde_json::json!("this is too long"));
882 assert!(result.is_err());
883
884 assert!(
885 matches!(result, Err(BaseError::StringTooLong(ref field, 16, 10)) if field == "name"),
886 "期望 StringTooLong 错误,实际: {:?}",
887 result
888 );
889 }
890
891 #[test]
892 fn test_validate_string_invalid_type() {
893 let field_type = FieldType::String { max_length: 10 };
894
895 assert!(field_type
897 .validate("name", &serde_json::json!(123))
898 .is_err());
899 assert!(field_type
900 .validate("name", &serde_json::json!(true))
901 .is_err());
902 assert!(field_type
903 .validate("name", &serde_json::json!(null))
904 .is_err());
905 }
906
907 #[test]
908 fn test_validate_integer_success() {
909 let field_type = FieldType::Integer;
910
911 assert!(field_type.validate("age", &serde_json::json!(25)).is_ok());
913 assert!(field_type.validate("age", &serde_json::json!(0)).is_ok());
914 assert!(field_type.validate("age", &serde_json::json!(-100)).is_ok());
915
916 assert!(field_type
918 .validate("age", &serde_json::json!(i32::MAX))
919 .is_ok());
920 assert!(field_type
921 .validate("age", &serde_json::json!(i32::MIN))
922 .is_ok());
923 }
924
925 #[test]
926 fn test_validate_integer_out_of_range() {
927 let field_type = FieldType::Integer;
928
929 let result = field_type.validate("age", &serde_json::json!(i64::MAX));
931 assert!(result.is_err());
932 }
933
934 #[test]
935 fn test_validate_integer_invalid_type() {
936 let field_type = FieldType::Integer;
937
938 assert!(field_type
940 .validate("age", &serde_json::json!("not a number"))
941 .is_err());
942 assert!(field_type
943 .validate("age", &serde_json::json!(true))
944 .is_err());
945 assert!(field_type.validate("age", &serde_json::json!(3.5)).is_err());
946 }
947
948 #[test]
949 fn test_validate_bigint_success() {
950 let field_type = FieldType::BigInt;
951
952 assert!(field_type
954 .validate("id", &serde_json::json!(123456789))
955 .is_ok());
956 assert!(field_type
957 .validate("id", &serde_json::json!(i64::MAX))
958 .is_ok());
959 assert!(field_type
960 .validate("id", &serde_json::json!(i64::MIN))
961 .is_ok());
962 }
963
964 #[test]
965 fn test_validate_bigint_invalid_type() {
966 let field_type = FieldType::BigInt;
967
968 assert!(field_type
970 .validate("id", &serde_json::json!("not a number"))
971 .is_err());
972 assert!(field_type.validate("id", &serde_json::json!(3.5)).is_err());
973 assert!(field_type
974 .validate("id", &serde_json::json!(u64::MAX))
975 .is_err());
976 }
977
978 #[test]
979 fn test_validate_float_success() {
980 let field_type = FieldType::Float;
981
982 assert!(field_type
984 .validate("price", &serde_json::json!(3.5))
985 .is_ok());
986 assert!(field_type
987 .validate("price", &serde_json::json!(0.0))
988 .is_ok());
989 assert!(field_type
990 .validate("price", &serde_json::json!(-1.5))
991 .is_ok());
992
993 assert!(field_type
995 .validate("price", &serde_json::json!(100))
996 .is_ok());
997 }
998
999 #[test]
1000 fn test_validate_float_invalid_type() {
1001 let field_type = FieldType::Float;
1002
1003 assert!(field_type
1005 .validate("price", &serde_json::json!("not a number"))
1006 .is_err());
1007 assert!(field_type
1008 .validate("price", &serde_json::json!(true))
1009 .is_err());
1010 }
1011
1012 #[test]
1013 fn test_validate_double_success() {
1014 let field_type = FieldType::Double;
1015
1016 assert!(field_type
1018 .validate("amount", &serde_json::json!(123.456))
1019 .is_ok());
1020 assert!(field_type
1021 .validate("amount", &serde_json::json!(0.0))
1022 .is_ok());
1023 assert!(field_type
1024 .validate("amount", &serde_json::json!(100))
1025 .is_ok());
1026 }
1027
1028 #[test]
1029 fn test_validate_double_invalid_type() {
1030 let field_type = FieldType::Double;
1031
1032 assert!(field_type
1034 .validate("amount", &serde_json::json!("not a number"))
1035 .is_err());
1036 assert!(field_type
1037 .validate("amount", &serde_json::json!(true))
1038 .is_err());
1039 }
1040
1041 #[test]
1042 fn test_validate_decimal_preserves_fixed_point_contract() {
1043 let field_type = FieldType::Decimal {
1044 precision: 8,
1045 scale: 2,
1046 };
1047 assert!(field_type
1048 .validate("amount", &serde_json::json!("123456.78"))
1049 .is_ok());
1050 assert!(field_type
1051 .validate("amount", &serde_json::json!("1234567.89"))
1052 .is_err());
1053 assert!(field_type
1054 .validate("amount", &serde_json::json!("1.234"))
1055 .is_err());
1056 assert!(field_type
1057 .validate("amount", &serde_json::json!("not-a-number"))
1058 .is_err());
1059 }
1060
1061 #[test]
1062 fn test_validate_boolean_success() {
1063 let field_type = FieldType::Boolean;
1064
1065 assert!(field_type
1067 .validate("active", &serde_json::json!(true))
1068 .is_ok());
1069 assert!(field_type
1070 .validate("active", &serde_json::json!(false))
1071 .is_ok());
1072 }
1073
1074 #[test]
1075 fn test_validate_boolean_invalid_type() {
1076 let field_type = FieldType::Boolean;
1077
1078 assert!(field_type
1080 .validate("active", &serde_json::json!("true"))
1081 .is_err());
1082 assert!(field_type
1083 .validate("active", &serde_json::json!(1))
1084 .is_err());
1085 assert!(field_type
1086 .validate("active", &serde_json::json!(0))
1087 .is_err());
1088 }
1089
1090 #[test]
1091 fn test_validate_date_success() {
1092 let field_type = FieldType::Date;
1093
1094 assert!(field_type
1095 .validate("birthday", &serde_json::json!("2026-05-27"))
1096 .is_ok());
1097 }
1098
1099 #[test]
1100 fn test_validate_date_invalid_format() {
1101 let field_type = FieldType::Date;
1102
1103 let result = field_type.validate("birthday", &serde_json::json!("2026/05/27"));
1104 assert!(result.is_err());
1105 assert!(
1106 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
1107 );
1108 }
1109
1110 #[test]
1111 fn test_validate_date_invalid_type() {
1112 let field_type = FieldType::Date;
1113
1114 let result = field_type.validate("birthday", &serde_json::json!(20260527));
1115 assert!(result.is_err());
1116 assert!(
1117 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
1118 );
1119 }
1120
1121 #[test]
1122 fn test_validate_datetime_success() {
1123 let field_type = FieldType::DateTime;
1124
1125 assert!(field_type
1126 .validate(
1127 "created_at",
1128 &serde_json::json!("2026-05-27T13:45:30+08:00"),
1129 )
1130 .is_ok());
1131 assert!(field_type
1132 .validate("created_at", &serde_json::json!("2026-05-27T05:45:30Z"))
1133 .is_ok());
1134 }
1135
1136 #[test]
1137 fn test_validate_datetime_invalid_format() {
1138 let field_type = FieldType::DateTime;
1139
1140 assert!(field_type
1142 .validate("created_at", &serde_json::json!("2026-05-27T13:45:30"))
1143 .is_err());
1144 assert!(field_type
1145 .validate("created_at", &serde_json::json!("2026-05-27 13:45:30"))
1146 .is_err());
1147
1148 let result = field_type.validate("created_at", &serde_json::json!("2026/05/27 13:45:30"));
1150 assert!(result.is_err());
1151 assert!(
1152 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
1153 );
1154 }
1155
1156 #[test]
1157 fn test_validate_datetime_matches_json_schema_date_time_format() {
1158 let field_type = FieldType::DateTime;
1160 let value = serde_json::json!("2026-05-27T13:45:30.123+08:00");
1161 assert!(field_type.validate("created_at", &value).is_ok());
1162 }
1163
1164 #[test]
1165 fn test_validate_timestamp_success() {
1166 let field_type = FieldType::Timestamp;
1167
1168 assert!(field_type
1169 .validate("created_at", &serde_json::json!(1_764_221_130_i64))
1170 .is_ok());
1171 }
1172
1173 #[test]
1174 fn test_validate_timestamp_invalid_type() {
1175 let field_type = FieldType::Timestamp;
1176
1177 let result = field_type.validate("created_at", &serde_json::json!("2026-05-27 13:45:30"));
1178 assert!(result.is_err());
1179 assert!(
1180 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
1181 );
1182 }
1183
1184 #[test]
1185 fn test_validate_text_success() {
1186 let field_type = FieldType::Text;
1187
1188 assert!(field_type
1190 .validate("content", &serde_json::json!("hello"))
1191 .is_ok());
1192 assert!(field_type
1193 .validate("content", &serde_json::json!("a".repeat(100_000)))
1194 .is_ok());
1195 assert!(field_type
1196 .validate("content", &serde_json::json!(""))
1197 .is_ok());
1198 }
1199
1200 #[test]
1201 fn test_validate_text_invalid_type() {
1202 let field_type = FieldType::Text;
1203
1204 let result = field_type.validate("content", &serde_json::json!(123));
1206 assert!(
1207 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "content")
1208 );
1209 assert!(field_type
1210 .validate("content", &serde_json::json!(true))
1211 .is_err());
1212 assert!(field_type
1213 .validate("content", &serde_json::json!(null))
1214 .is_err());
1215 }
1216
1217 #[test]
1218 fn test_validate_enum_success() {
1219 let field_type = FieldType::Enum {
1220 values: vec![
1221 "pending".to_string(),
1222 "approved".to_string(),
1223 "rejected".to_string(),
1224 ],
1225 };
1226
1227 assert!(field_type
1229 .validate("status", &serde_json::json!("pending"))
1230 .is_ok());
1231 assert!(field_type
1232 .validate("status", &serde_json::json!("approved"))
1233 .is_ok());
1234 assert!(field_type
1235 .validate("status", &serde_json::json!("rejected"))
1236 .is_ok());
1237 }
1238
1239 #[test]
1240 fn test_validate_enum_invalid_value() {
1241 let field_type = FieldType::Enum {
1242 values: vec![
1243 "pending".to_string(),
1244 "approved".to_string(),
1245 "rejected".to_string(),
1246 ],
1247 };
1248
1249 let result = field_type.validate("status", &serde_json::json!("invalid"));
1251 assert!(result.is_err());
1252
1253 assert!(
1254 matches!(result, Err(BaseError::InvalidEnumValue(ref field, ref value)) if field == "status" && value == "invalid"),
1255 "期望 InvalidEnumValue 错误,实际: {:?}",
1256 result
1257 );
1258 }
1259
1260 #[test]
1261 fn test_validate_enum_invalid_type() {
1262 let field_type = FieldType::Enum {
1263 values: vec!["pending".to_string()],
1264 };
1265
1266 assert!(field_type
1268 .validate("status", &serde_json::json!(123))
1269 .is_err());
1270 assert!(field_type
1271 .validate("status", &serde_json::json!(true))
1272 .is_err());
1273 }
1274
1275 #[test]
1276 fn test_validate_json_success() {
1277 let field_type = FieldType::Json;
1278
1279 assert!(field_type
1281 .validate("data", &serde_json::json!({"key": "value"}))
1282 .is_ok());
1283
1284 assert!(field_type
1286 .validate("data", &serde_json::json!([1, 2, 3]))
1287 .is_ok());
1288 }
1289
1290 #[test]
1291 fn test_validate_json_invalid_format() {
1292 let field_type = FieldType::Json;
1293
1294 let result = field_type.validate("data", &serde_json::json!("not a json"));
1296 assert!(result.is_err());
1297
1298 assert!(field_type
1299 .validate("data", &serde_json::json!("{\"key\": \"value\"}"))
1300 .is_err());
1301 assert!(field_type
1302 .validate("data", &serde_json::json!("[1, 2, 3]"))
1303 .is_err());
1304
1305 assert!(
1306 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "data"),
1307 "期望 InvalidFieldType 错误,实际: {:?}",
1308 result
1309 );
1310 }
1311
1312 #[test]
1313 fn test_validate_json_invalid_type() {
1314 let field_type = FieldType::Json;
1315
1316 assert!(field_type
1318 .validate("data", &serde_json::json!(123))
1319 .is_err());
1320 assert!(field_type
1321 .validate("data", &serde_json::json!(true))
1322 .is_err());
1323 assert!(field_type
1324 .validate("data", &serde_json::json!(null))
1325 .is_err());
1326 }
1327
1328 #[test]
1331 fn test_new_variants_display_name_and_predicates() {
1332 assert_eq!(FieldType::Uuid.display_name(), "UUID");
1333 assert_eq!(FieldType::Bytes.display_name(), "二进制");
1334 assert_eq!(FieldType::array(FieldType::Integer).display_name(), "数组");
1335
1336 assert!(FieldType::Uuid.is_uuid());
1337 assert!(!FieldType::Bytes.is_uuid());
1338 assert!(FieldType::Bytes.is_binary());
1339 assert!(!FieldType::Uuid.is_binary());
1340 let array = FieldType::array(FieldType::Text);
1341 assert!(array.is_array());
1342 assert!(!FieldType::Text.is_array());
1343 assert!(!array.is_text());
1344 assert!(!array.is_numeric());
1345 }
1346
1347 #[test]
1348 fn test_validate_uuid_and_bytes_require_strings() {
1349 assert!(FieldType::Uuid
1350 .validate(
1351 "uid",
1352 &serde_json::json!("11111111-1111-1111-1111-111111111111")
1353 )
1354 .is_ok());
1355 assert!(FieldType::Uuid
1356 .validate("uid", &serde_json::json!(123))
1357 .is_err());
1358
1359 assert!(FieldType::Bytes
1360 .validate("payload", &serde_json::json!("3q2+7w=="))
1361 .is_ok());
1362 assert!(FieldType::Bytes
1363 .validate("payload", &serde_json::json!([1, 2]))
1364 .is_err());
1365 }
1366
1367 #[test]
1368 fn test_validate_array_recurses_scalar_rules_and_allows_null_elements() {
1369 let field_type = FieldType::array(FieldType::Integer);
1370 assert!(field_type
1371 .validate("numbers", &serde_json::json!([1, 2, null]))
1372 .is_ok());
1373 assert!(field_type
1375 .validate("numbers", &serde_json::json!([1, "two"]))
1376 .is_err());
1377 assert!(field_type
1379 .validate("numbers", &serde_json::json!(1))
1380 .is_err());
1381
1382 let text_array = FieldType::array(FieldType::Text);
1383 assert!(text_array
1384 .validate("tags", &serde_json::json!(["a", null, "c"]))
1385 .is_ok());
1386 assert!(text_array
1387 .validate("tags", &serde_json::json!([1]))
1388 .is_err());
1389 }
1390}