1pub const MAX_VARCHAR_LENGTH: usize = 16_383;
10
11use crate::error::BaseError;
12use serde::{Deserialize, Serialize};
13
14fn value_type_name(value: &serde_json::Value) -> &'static str {
24 match value {
25 serde_json::Value::Null => "null",
26 serde_json::Value::Bool(_) => "boolean",
27 serde_json::Value::Number(_) => "number",
28 serde_json::Value::String(_) => "string",
29 serde_json::Value::Array(_) => "array",
30 serde_json::Value::Object(_) => "object",
31 }
32}
33
34#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
59#[non_exhaustive]
60pub enum FieldType {
61 String {
77 max_length: usize,
79 },
80
81 Integer,
93
94 BigInt,
106
107 Float,
119
120 Double,
132
133 Decimal {
135 precision: u8,
137 scale: u8,
139 },
140
141 Boolean,
153
154 Date,
166
167 DateTime,
179
180 Timestamp,
192
193 Json,
205
206 Text,
218
219 Enum {
241 values: Vec<String>,
243 },
244}
245
246impl FieldType {
247 pub fn display_name(&self) -> &str {
265 match self {
266 FieldType::String { .. } => "字符串",
267 FieldType::Integer => "整数",
268 FieldType::BigInt => "长整数",
269 FieldType::Float => "单精度浮点数",
270 FieldType::Double => "双精度浮点数",
271 FieldType::Decimal { .. } => "定点小数",
272 FieldType::Boolean => "布尔值",
273 FieldType::Date => "日期",
274 FieldType::DateTime => "日期时间",
275 FieldType::Timestamp => "时间戳",
276 FieldType::Json => "JSON",
277 FieldType::Text => "文本",
278 FieldType::Enum { .. } => "枚举",
279 }
280 }
281
282 pub fn is_numeric(&self) -> bool {
298 matches!(
299 self,
300 FieldType::Integer
301 | FieldType::BigInt
302 | FieldType::Float
303 | FieldType::Double
304 | FieldType::Decimal { .. }
305 )
306 }
307
308 pub fn is_temporal(&self) -> bool {
324 matches!(
325 self,
326 FieldType::Date | FieldType::DateTime | FieldType::Timestamp
327 )
328 }
329
330 pub fn is_text(&self) -> bool {
346 matches!(self, FieldType::String { .. } | FieldType::Text)
347 }
348
349 pub fn validate(&self, field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
375 match self {
376 FieldType::String { max_length } => {
378 if let Some(s) = value.as_str() {
379 let len = s.chars().count();
380 if len > *max_length {
381 return Err(BaseError::StringTooLong(
382 field_name.to_string(),
383 len,
384 *max_length,
385 ));
386 }
387 Ok(())
388 } else {
389 Err(BaseError::InvalidFieldType(
390 field_name.to_string(),
391 format!("期望字符串类型,实际类型: {}", value_type_name(value)),
392 ))
393 }
394 }
395
396 FieldType::Integer => {
398 if value.is_i64() || value.is_u64() {
399 if let Some(n) = value.as_i64() {
401 if n >= i32::MIN as i64 && n <= i32::MAX as i64 {
402 return Ok(());
403 }
404 }
405 Err(BaseError::InvalidFieldType(
406 field_name.to_string(),
407 "整数值超出 i32 范围".to_string(),
408 ))
409 } else {
410 Err(BaseError::InvalidFieldType(
411 field_name.to_string(),
412 format!("期望整数类型,实际类型: {}", value_type_name(value)),
413 ))
414 }
415 }
416
417 FieldType::BigInt => {
419 if value.as_i64().is_some() {
420 Ok(())
421 } else {
422 Err(BaseError::InvalidFieldType(
423 field_name.to_string(),
424 format!("期望 i64 范围内的长整数,实际值: {}", value),
425 ))
426 }
427 }
428
429 FieldType::Float => {
431 if value.is_f64() || value.is_i64() || value.is_u64() {
432 if let Some(n) = value.as_f64() {
434 if n.is_finite() && n.abs() <= f32::MAX as f64 {
435 return Ok(());
436 }
437 }
438 Err(BaseError::InvalidFieldType(
439 field_name.to_string(),
440 "浮点数值超出 f32 范围".to_string(),
441 ))
442 } else {
443 Err(BaseError::InvalidFieldType(
444 field_name.to_string(),
445 format!("期望浮点数类型,实际类型: {}", value_type_name(value)),
446 ))
447 }
448 }
449
450 FieldType::Double => {
452 if value.is_f64() || value.is_i64() || value.is_u64() {
453 Ok(())
454 } else {
455 Err(BaseError::InvalidFieldType(
456 field_name.to_string(),
457 format!("期望双精度浮点数类型,实际类型: {}", value_type_name(value)),
458 ))
459 }
460 }
461
462 FieldType::Decimal { precision, scale } => {
463 validate_decimal(field_name, value, *precision, *scale)
464 }
465
466 FieldType::Boolean => {
468 if value.is_boolean() {
469 Ok(())
470 } else {
471 Err(BaseError::InvalidFieldType(
472 field_name.to_string(),
473 format!("期望布尔类型,实际类型: {}", value_type_name(value)),
474 ))
475 }
476 }
477
478 FieldType::Date => validate_date(field_name, value),
480
481 FieldType::DateTime => validate_datetime(field_name, value),
483
484 FieldType::Timestamp => validate_timestamp(field_name, value),
486
487 FieldType::Enum { values } => {
489 if let Some(s) = value.as_str() {
490 if values.contains(&s.to_string()) {
491 Ok(())
492 } else {
493 Err(BaseError::InvalidEnumValue(
494 field_name.to_string(),
495 s.to_string(),
496 ))
497 }
498 } else {
499 Err(BaseError::InvalidFieldType(
500 field_name.to_string(),
501 format!(
502 "期望字符串类型的枚举值,实际类型: {}",
503 value_type_name(value)
504 ),
505 ))
506 }
507 }
508
509 FieldType::Json => {
511 if value.is_object() || value.is_array() {
512 Ok(())
513 } else {
514 Err(BaseError::InvalidFieldType(
515 field_name.to_string(),
516 format!("期望 JSON 对象或数组,实际类型: {}", value_type_name(value)),
517 ))
518 }
519 }
520
521 FieldType::Text => {
523 if value.as_str().is_some() {
524 Ok(())
525 } else {
526 Err(BaseError::InvalidFieldType(
527 field_name.to_string(),
528 format!("期望文本字符串类型,实际类型: {}", value_type_name(value)),
529 ))
530 }
531 }
532 }
533 }
534}
535
536fn validate_decimal(
537 field_name: &str,
538 value: &serde_json::Value,
539 precision: u8,
540 scale: u8,
541) -> Result<(), BaseError> {
542 let text = match value {
543 serde_json::Value::String(value) => std::borrow::Cow::Borrowed(value.as_str()),
544 serde_json::Value::Number(value) => std::borrow::Cow::Owned(value.to_string()),
545 _ => {
546 return Err(BaseError::InvalidFieldType(
547 field_name.to_string(),
548 format!(
549 "期望十进制数字或字符串,实际类型: {}",
550 value_type_name(value)
551 ),
552 ));
553 }
554 };
555 let unsigned = text.strip_prefix('-').unwrap_or(text.as_ref());
556 let (integer, fraction) = unsigned.split_once('.').unwrap_or((unsigned, ""));
557 let digits = integer.len() + fraction.len();
558 let valid = !integer.is_empty()
559 && integer.bytes().all(|byte| byte.is_ascii_digit())
560 && fraction.bytes().all(|byte| byte.is_ascii_digit())
561 && digits <= usize::from(precision)
562 && fraction.len() <= usize::from(scale);
563 if valid {
564 Ok(())
565 } else {
566 Err(BaseError::InvalidFieldType(
567 field_name.to_string(),
568 format!("值 {text} 不符合 DECIMAL({precision}, {scale})"),
569 ))
570 }
571}
572
573fn validate_date(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
574 if let Some(s) = value.as_str() {
575 chrono::NaiveDate::parse_from_str(s, "%Y-%m-%d")
576 .map(|_| ())
577 .map_err(|_| {
578 BaseError::InvalidFieldType(
579 field_name.to_string(),
580 format!("日期格式无效,期望 YYYY-MM-DD,实际: {}", s),
581 )
582 })
583 } else {
584 Err(BaseError::InvalidFieldType(
585 field_name.to_string(),
586 format!("期望日期字符串类型,实际类型: {}", value_type_name(value)),
587 ))
588 }
589}
590
591fn validate_datetime(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
592 if let Some(s) = value.as_str() {
593 chrono::DateTime::parse_from_rfc3339(s)
594 .map(|_| ())
595 .map_err(|_| {
596 BaseError::InvalidFieldType(
597 field_name.to_string(),
598 format!("日期时间格式无效,期望 RFC 3339,实际: {s}"),
599 )
600 })
601 } else {
602 Err(BaseError::InvalidFieldType(
603 field_name.to_string(),
604 format!(
605 "期望日期时间字符串类型,实际类型: {}",
606 value_type_name(value)
607 ),
608 ))
609 }
610}
611
612fn validate_timestamp(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
613 if let Some(ts) = value.as_i64() {
614 chrono::DateTime::<chrono::Utc>::from_timestamp_secs(ts)
615 .map(|_| ())
616 .ok_or_else(|| {
617 BaseError::InvalidFieldType(
618 field_name.to_string(),
619 format!("时间戳超出有效范围,实际: {}", ts),
620 )
621 })
622 } else {
623 Err(BaseError::InvalidFieldType(
624 field_name.to_string(),
625 format!("期望 Unix 时间戳整数,实际类型: {}", value_type_name(value)),
626 ))
627 }
628}
629
630#[cfg(test)]
631mod tests {
632 use super::*;
633
634 #[test]
635 fn test_field_type_display_name() {
636 assert_eq!(
637 FieldType::String { max_length: 50 }.display_name(),
638 "字符串"
639 );
640 assert_eq!(FieldType::Integer.display_name(), "整数");
641 assert_eq!(FieldType::BigInt.display_name(), "长整数");
642 assert_eq!(FieldType::Float.display_name(), "单精度浮点数");
643 assert_eq!(FieldType::Double.display_name(), "双精度浮点数");
644 assert_eq!(FieldType::Boolean.display_name(), "布尔值");
645 assert_eq!(FieldType::Date.display_name(), "日期");
646 assert_eq!(FieldType::DateTime.display_name(), "日期时间");
647 assert_eq!(FieldType::Timestamp.display_name(), "时间戳");
648 assert_eq!(FieldType::Json.display_name(), "JSON");
649 assert_eq!(FieldType::Text.display_name(), "文本");
650 assert_eq!(
651 FieldType::Enum {
652 values: vec!["a".to_string()]
653 }
654 .display_name(),
655 "枚举"
656 );
657 }
658
659 #[test]
660 fn test_is_numeric() {
661 assert!(FieldType::Integer.is_numeric());
662 assert!(FieldType::BigInt.is_numeric());
663 assert!(FieldType::Float.is_numeric());
664 assert!(FieldType::Double.is_numeric());
665 assert!(!FieldType::String { max_length: 50 }.is_numeric());
666 assert!(!FieldType::Boolean.is_numeric());
667 }
668
669 #[test]
670 fn test_is_temporal() {
671 assert!(FieldType::Date.is_temporal());
672 assert!(FieldType::DateTime.is_temporal());
673 assert!(FieldType::Timestamp.is_temporal());
674 assert!(!FieldType::String { max_length: 50 }.is_temporal());
675 assert!(!FieldType::Integer.is_temporal());
676 }
677
678 #[test]
679 fn test_is_text() {
680 assert!(FieldType::String { max_length: 50 }.is_text());
681 assert!(FieldType::Text.is_text());
682 assert!(!FieldType::Integer.is_text());
683 assert!(!FieldType::Boolean.is_text());
684 }
685
686 #[test]
687 fn test_field_type_equality() {
688 let type1 = FieldType::String { max_length: 50 };
689 let type2 = FieldType::String { max_length: 50 };
690 let type3 = FieldType::String { max_length: 100 };
691
692 assert_eq!(type1, type2);
693 assert_ne!(type1, type3);
694 }
695
696 #[test]
697 fn test_enum_type() {
698 let enum_type = FieldType::Enum {
699 values: vec![
700 "pending".to_string(),
701 "approved".to_string(),
702 "rejected".to_string(),
703 ],
704 };
705
706 assert_eq!(enum_type.display_name(), "枚举");
707 assert!(!enum_type.is_numeric());
708 assert!(!enum_type.is_temporal());
709 assert!(!enum_type.is_text());
710 }
711
712 #[test]
715 fn test_validate_string_success() {
716 let field_type = FieldType::String { max_length: 10 };
717
718 assert!(field_type
720 .validate("name", &serde_json::json!("hello"))
721 .is_ok());
722 assert!(field_type.validate("name", &serde_json::json!("")).is_ok());
723
724 assert!(field_type
726 .validate("name", &serde_json::json!("1234567890"))
727 .is_ok());
728 }
729
730 #[test]
731 fn test_validate_string_too_long() {
732 let field_type = FieldType::String { max_length: 10 };
733
734 let result = field_type.validate("name", &serde_json::json!("this is too long"));
736 assert!(result.is_err());
737
738 assert!(
739 matches!(result, Err(BaseError::StringTooLong(ref field, 16, 10)) if field == "name"),
740 "期望 StringTooLong 错误,实际: {:?}",
741 result
742 );
743 }
744
745 #[test]
746 fn test_validate_string_invalid_type() {
747 let field_type = FieldType::String { max_length: 10 };
748
749 assert!(field_type
751 .validate("name", &serde_json::json!(123))
752 .is_err());
753 assert!(field_type
754 .validate("name", &serde_json::json!(true))
755 .is_err());
756 assert!(field_type
757 .validate("name", &serde_json::json!(null))
758 .is_err());
759 }
760
761 #[test]
762 fn test_validate_integer_success() {
763 let field_type = FieldType::Integer;
764
765 assert!(field_type.validate("age", &serde_json::json!(25)).is_ok());
767 assert!(field_type.validate("age", &serde_json::json!(0)).is_ok());
768 assert!(field_type.validate("age", &serde_json::json!(-100)).is_ok());
769
770 assert!(field_type
772 .validate("age", &serde_json::json!(i32::MAX))
773 .is_ok());
774 assert!(field_type
775 .validate("age", &serde_json::json!(i32::MIN))
776 .is_ok());
777 }
778
779 #[test]
780 fn test_validate_integer_out_of_range() {
781 let field_type = FieldType::Integer;
782
783 let result = field_type.validate("age", &serde_json::json!(i64::MAX));
785 assert!(result.is_err());
786 }
787
788 #[test]
789 fn test_validate_integer_invalid_type() {
790 let field_type = FieldType::Integer;
791
792 assert!(field_type
794 .validate("age", &serde_json::json!("not a number"))
795 .is_err());
796 assert!(field_type
797 .validate("age", &serde_json::json!(true))
798 .is_err());
799 assert!(field_type.validate("age", &serde_json::json!(3.5)).is_err());
800 }
801
802 #[test]
803 fn test_validate_bigint_success() {
804 let field_type = FieldType::BigInt;
805
806 assert!(field_type
808 .validate("id", &serde_json::json!(123456789))
809 .is_ok());
810 assert!(field_type
811 .validate("id", &serde_json::json!(i64::MAX))
812 .is_ok());
813 assert!(field_type
814 .validate("id", &serde_json::json!(i64::MIN))
815 .is_ok());
816 }
817
818 #[test]
819 fn test_validate_bigint_invalid_type() {
820 let field_type = FieldType::BigInt;
821
822 assert!(field_type
824 .validate("id", &serde_json::json!("not a number"))
825 .is_err());
826 assert!(field_type.validate("id", &serde_json::json!(3.5)).is_err());
827 assert!(field_type
828 .validate("id", &serde_json::json!(u64::MAX))
829 .is_err());
830 }
831
832 #[test]
833 fn test_validate_float_success() {
834 let field_type = FieldType::Float;
835
836 assert!(field_type
838 .validate("price", &serde_json::json!(3.5))
839 .is_ok());
840 assert!(field_type
841 .validate("price", &serde_json::json!(0.0))
842 .is_ok());
843 assert!(field_type
844 .validate("price", &serde_json::json!(-1.5))
845 .is_ok());
846
847 assert!(field_type
849 .validate("price", &serde_json::json!(100))
850 .is_ok());
851 }
852
853 #[test]
854 fn test_validate_float_invalid_type() {
855 let field_type = FieldType::Float;
856
857 assert!(field_type
859 .validate("price", &serde_json::json!("not a number"))
860 .is_err());
861 assert!(field_type
862 .validate("price", &serde_json::json!(true))
863 .is_err());
864 }
865
866 #[test]
867 fn test_validate_double_success() {
868 let field_type = FieldType::Double;
869
870 assert!(field_type
872 .validate("amount", &serde_json::json!(123.456))
873 .is_ok());
874 assert!(field_type
875 .validate("amount", &serde_json::json!(0.0))
876 .is_ok());
877 assert!(field_type
878 .validate("amount", &serde_json::json!(100))
879 .is_ok());
880 }
881
882 #[test]
883 fn test_validate_double_invalid_type() {
884 let field_type = FieldType::Double;
885
886 assert!(field_type
888 .validate("amount", &serde_json::json!("not a number"))
889 .is_err());
890 assert!(field_type
891 .validate("amount", &serde_json::json!(true))
892 .is_err());
893 }
894
895 #[test]
896 fn test_validate_decimal_preserves_fixed_point_contract() {
897 let field_type = FieldType::Decimal {
898 precision: 8,
899 scale: 2,
900 };
901 assert!(field_type
902 .validate("amount", &serde_json::json!("123456.78"))
903 .is_ok());
904 assert!(field_type
905 .validate("amount", &serde_json::json!("1234567.89"))
906 .is_err());
907 assert!(field_type
908 .validate("amount", &serde_json::json!("1.234"))
909 .is_err());
910 assert!(field_type
911 .validate("amount", &serde_json::json!("not-a-number"))
912 .is_err());
913 }
914
915 #[test]
916 fn test_validate_boolean_success() {
917 let field_type = FieldType::Boolean;
918
919 assert!(field_type
921 .validate("active", &serde_json::json!(true))
922 .is_ok());
923 assert!(field_type
924 .validate("active", &serde_json::json!(false))
925 .is_ok());
926 }
927
928 #[test]
929 fn test_validate_boolean_invalid_type() {
930 let field_type = FieldType::Boolean;
931
932 assert!(field_type
934 .validate("active", &serde_json::json!("true"))
935 .is_err());
936 assert!(field_type
937 .validate("active", &serde_json::json!(1))
938 .is_err());
939 assert!(field_type
940 .validate("active", &serde_json::json!(0))
941 .is_err());
942 }
943
944 #[test]
945 fn test_validate_date_success() {
946 let field_type = FieldType::Date;
947
948 assert!(field_type
949 .validate("birthday", &serde_json::json!("2026-05-27"))
950 .is_ok());
951 }
952
953 #[test]
954 fn test_validate_date_invalid_format() {
955 let field_type = FieldType::Date;
956
957 let result = field_type.validate("birthday", &serde_json::json!("2026/05/27"));
958 assert!(result.is_err());
959 assert!(
960 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
961 );
962 }
963
964 #[test]
965 fn test_validate_date_invalid_type() {
966 let field_type = FieldType::Date;
967
968 let result = field_type.validate("birthday", &serde_json::json!(20260527));
969 assert!(result.is_err());
970 assert!(
971 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
972 );
973 }
974
975 #[test]
976 fn test_validate_datetime_success() {
977 let field_type = FieldType::DateTime;
978
979 assert!(field_type
980 .validate(
981 "created_at",
982 &serde_json::json!("2026-05-27T13:45:30+08:00"),
983 )
984 .is_ok());
985 assert!(field_type
986 .validate("created_at", &serde_json::json!("2026-05-27T05:45:30Z"))
987 .is_ok());
988 }
989
990 #[test]
991 fn test_validate_datetime_invalid_format() {
992 let field_type = FieldType::DateTime;
993
994 assert!(field_type
996 .validate("created_at", &serde_json::json!("2026-05-27T13:45:30"))
997 .is_err());
998 assert!(field_type
999 .validate("created_at", &serde_json::json!("2026-05-27 13:45:30"))
1000 .is_err());
1001
1002 let result = field_type.validate("created_at", &serde_json::json!("2026/05/27 13:45:30"));
1004 assert!(result.is_err());
1005 assert!(
1006 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
1007 );
1008 }
1009
1010 #[test]
1011 fn test_validate_datetime_matches_json_schema_date_time_format() {
1012 let field_type = FieldType::DateTime;
1014 let value = serde_json::json!("2026-05-27T13:45:30.123+08:00");
1015 assert!(field_type.validate("created_at", &value).is_ok());
1016 }
1017
1018 #[test]
1019 fn test_validate_timestamp_success() {
1020 let field_type = FieldType::Timestamp;
1021
1022 assert!(field_type
1023 .validate("created_at", &serde_json::json!(1_764_221_130_i64))
1024 .is_ok());
1025 }
1026
1027 #[test]
1028 fn test_validate_timestamp_invalid_type() {
1029 let field_type = FieldType::Timestamp;
1030
1031 let result = field_type.validate("created_at", &serde_json::json!("2026-05-27 13:45:30"));
1032 assert!(result.is_err());
1033 assert!(
1034 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
1035 );
1036 }
1037
1038 #[test]
1039 fn test_validate_text_success() {
1040 let field_type = FieldType::Text;
1041
1042 assert!(field_type
1044 .validate("content", &serde_json::json!("hello"))
1045 .is_ok());
1046 assert!(field_type
1047 .validate("content", &serde_json::json!("a".repeat(100_000)))
1048 .is_ok());
1049 assert!(field_type
1050 .validate("content", &serde_json::json!(""))
1051 .is_ok());
1052 }
1053
1054 #[test]
1055 fn test_validate_text_invalid_type() {
1056 let field_type = FieldType::Text;
1057
1058 let result = field_type.validate("content", &serde_json::json!(123));
1060 assert!(
1061 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "content")
1062 );
1063 assert!(field_type
1064 .validate("content", &serde_json::json!(true))
1065 .is_err());
1066 assert!(field_type
1067 .validate("content", &serde_json::json!(null))
1068 .is_err());
1069 }
1070
1071 #[test]
1072 fn test_validate_enum_success() {
1073 let field_type = FieldType::Enum {
1074 values: vec![
1075 "pending".to_string(),
1076 "approved".to_string(),
1077 "rejected".to_string(),
1078 ],
1079 };
1080
1081 assert!(field_type
1083 .validate("status", &serde_json::json!("pending"))
1084 .is_ok());
1085 assert!(field_type
1086 .validate("status", &serde_json::json!("approved"))
1087 .is_ok());
1088 assert!(field_type
1089 .validate("status", &serde_json::json!("rejected"))
1090 .is_ok());
1091 }
1092
1093 #[test]
1094 fn test_validate_enum_invalid_value() {
1095 let field_type = FieldType::Enum {
1096 values: vec![
1097 "pending".to_string(),
1098 "approved".to_string(),
1099 "rejected".to_string(),
1100 ],
1101 };
1102
1103 let result = field_type.validate("status", &serde_json::json!("invalid"));
1105 assert!(result.is_err());
1106
1107 assert!(
1108 matches!(result, Err(BaseError::InvalidEnumValue(ref field, ref value)) if field == "status" && value == "invalid"),
1109 "期望 InvalidEnumValue 错误,实际: {:?}",
1110 result
1111 );
1112 }
1113
1114 #[test]
1115 fn test_validate_enum_invalid_type() {
1116 let field_type = FieldType::Enum {
1117 values: vec!["pending".to_string()],
1118 };
1119
1120 assert!(field_type
1122 .validate("status", &serde_json::json!(123))
1123 .is_err());
1124 assert!(field_type
1125 .validate("status", &serde_json::json!(true))
1126 .is_err());
1127 }
1128
1129 #[test]
1130 fn test_validate_json_success() {
1131 let field_type = FieldType::Json;
1132
1133 assert!(field_type
1135 .validate("data", &serde_json::json!({"key": "value"}))
1136 .is_ok());
1137
1138 assert!(field_type
1140 .validate("data", &serde_json::json!([1, 2, 3]))
1141 .is_ok());
1142 }
1143
1144 #[test]
1145 fn test_validate_json_invalid_format() {
1146 let field_type = FieldType::Json;
1147
1148 let result = field_type.validate("data", &serde_json::json!("not a json"));
1150 assert!(result.is_err());
1151
1152 assert!(field_type
1153 .validate("data", &serde_json::json!("{\"key\": \"value\"}"))
1154 .is_err());
1155 assert!(field_type
1156 .validate("data", &serde_json::json!("[1, 2, 3]"))
1157 .is_err());
1158
1159 assert!(
1160 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "data"),
1161 "期望 InvalidFieldType 错误,实际: {:?}",
1162 result
1163 );
1164 }
1165
1166 #[test]
1167 fn test_validate_json_invalid_type() {
1168 let field_type = FieldType::Json;
1169
1170 assert!(field_type
1172 .validate("data", &serde_json::json!(123))
1173 .is_err());
1174 assert!(field_type
1175 .validate("data", &serde_json::json!(true))
1176 .is_err());
1177 assert!(field_type
1178 .validate("data", &serde_json::json!(null))
1179 .is_err());
1180 }
1181}