1use crate::error::BaseError;
6use serde::{Deserialize, Serialize};
7
8fn value_type_name(value: &serde_json::Value) -> &'static str {
18 match value {
19 serde_json::Value::Null => "null",
20 serde_json::Value::Bool(_) => "boolean",
21 serde_json::Value::Number(_) => "number",
22 serde_json::Value::String(_) => "string",
23 serde_json::Value::Array(_) => "array",
24 serde_json::Value::Object(_) => "object",
25 }
26}
27
28#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
60#[non_exhaustive]
61pub enum FieldType {
62 String {
78 max_length: usize,
80 },
81
82 Integer,
94
95 BigInt,
107
108 Float,
120
121 Double,
133
134 Boolean,
146
147 Date,
159
160 DateTime,
172
173 Timestamp,
185
186 Json,
198
199 Text,
211
212 Enum {
234 values: Vec<String>,
236 },
237
238 ForeignKey {
258 table: String,
260 field: String,
262 },
263}
264
265impl FieldType {
266 pub fn display_name(&self) -> &str {
284 match self {
285 FieldType::String { .. } => "字符串",
286 FieldType::Integer => "整数",
287 FieldType::BigInt => "长整数",
288 FieldType::Float => "单精度浮点数",
289 FieldType::Double => "双精度浮点数",
290 FieldType::Boolean => "布尔值",
291 FieldType::Date => "日期",
292 FieldType::DateTime => "日期时间",
293 FieldType::Timestamp => "时间戳",
294 FieldType::Json => "JSON",
295 FieldType::Text => "文本",
296 FieldType::Enum { .. } => "枚举",
297 FieldType::ForeignKey { .. } => "外键",
298 }
299 }
300
301 pub fn is_numeric(&self) -> bool {
317 matches!(
318 self,
319 FieldType::Integer | FieldType::BigInt | FieldType::Float | FieldType::Double
320 )
321 }
322
323 pub fn is_temporal(&self) -> bool {
339 matches!(
340 self,
341 FieldType::Date | FieldType::DateTime | FieldType::Timestamp
342 )
343 }
344
345 pub fn is_text(&self) -> bool {
361 matches!(self, FieldType::String { .. } | FieldType::Text)
362 }
363
364 pub fn validate(&self, field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
390 match self {
391 FieldType::String { max_length } => {
393 if let Some(s) = value.as_str() {
394 let len = s.chars().count();
395 if len > *max_length {
396 return Err(BaseError::StringTooLong(
397 field_name.to_string(),
398 len,
399 *max_length,
400 ));
401 }
402 Ok(())
403 } else {
404 Err(BaseError::InvalidFieldType(
405 field_name.to_string(),
406 format!("期望字符串类型,实际类型: {}", value_type_name(value)),
407 ))
408 }
409 }
410
411 FieldType::Integer => {
413 if value.is_i64() || value.is_u64() {
414 if let Some(n) = value.as_i64() {
416 if n >= i32::MIN as i64 && n <= i32::MAX as i64 {
417 return Ok(());
418 }
419 }
420 Err(BaseError::InvalidFieldType(
421 field_name.to_string(),
422 "整数值超出 i32 范围".to_string(),
423 ))
424 } else {
425 Err(BaseError::InvalidFieldType(
426 field_name.to_string(),
427 format!("期望整数类型,实际类型: {}", value_type_name(value)),
428 ))
429 }
430 }
431
432 FieldType::BigInt => {
434 if value.is_i64() || value.is_u64() {
435 Ok(())
436 } else {
437 Err(BaseError::InvalidFieldType(
438 field_name.to_string(),
439 format!("期望长整数类型,实际类型: {}", value_type_name(value)),
440 ))
441 }
442 }
443
444 FieldType::Float => {
446 if value.is_f64() || value.is_i64() || value.is_u64() {
447 if let Some(n) = value.as_f64() {
449 if n.is_finite() && n.abs() <= f32::MAX as f64 {
450 return Ok(());
451 }
452 }
453 Err(BaseError::InvalidFieldType(
454 field_name.to_string(),
455 "浮点数值超出 f32 范围".to_string(),
456 ))
457 } else {
458 Err(BaseError::InvalidFieldType(
459 field_name.to_string(),
460 format!("期望浮点数类型,实际类型: {}", value_type_name(value)),
461 ))
462 }
463 }
464
465 FieldType::Double => {
467 if value.is_f64() || value.is_i64() || value.is_u64() {
468 Ok(())
469 } else {
470 Err(BaseError::InvalidFieldType(
471 field_name.to_string(),
472 format!("期望双精度浮点数类型,实际类型: {}", value_type_name(value)),
473 ))
474 }
475 }
476
477 FieldType::Boolean => {
479 if value.is_boolean() {
480 Ok(())
481 } else {
482 Err(BaseError::InvalidFieldType(
483 field_name.to_string(),
484 format!("期望布尔类型,实际类型: {}", value_type_name(value)),
485 ))
486 }
487 }
488
489 FieldType::Date => validate_date(field_name, value),
491
492 FieldType::DateTime => validate_datetime(field_name, value),
494
495 FieldType::Timestamp => validate_timestamp(field_name, value),
497
498 FieldType::Enum { values } => {
500 if let Some(s) = value.as_str() {
501 if values.contains(&s.to_string()) {
502 Ok(())
503 } else {
504 Err(BaseError::InvalidEnumValue(
505 field_name.to_string(),
506 s.to_string(),
507 ))
508 }
509 } else {
510 Err(BaseError::InvalidFieldType(
511 field_name.to_string(),
512 format!(
513 "期望字符串类型的枚举值,实际类型: {}",
514 value_type_name(value)
515 ),
516 ))
517 }
518 }
519
520 FieldType::Json => {
522 if let Some(s) = value.as_str() {
524 serde_json::from_str::<serde_json::Value>(s)
525 .map(|_| ())
526 .map_err(|e| {
527 BaseError::InvalidJsonFormat(field_name.to_string(), e.to_string())
528 })
529 } else {
530 if value.is_object() || value.is_array() {
532 Ok(())
533 } else {
534 Err(BaseError::InvalidFieldType(
535 field_name.to_string(),
536 format!("期望 JSON 对象或数组,实际类型: {}", value_type_name(value)),
537 ))
538 }
539 }
540 }
541
542 FieldType::Text => {
544 if value.as_str().is_some() {
545 Ok(())
546 } else {
547 Err(BaseError::InvalidFieldType(
548 field_name.to_string(),
549 format!("期望文本字符串类型,实际类型: {}", value_type_name(value)),
550 ))
551 }
552 }
553
554 FieldType::ForeignKey { .. } => Ok(()),
556 }
557 }
558}
559
560fn validate_date(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
561 if let Some(s) = value.as_str() {
562 chrono::NaiveDate::parse_from_str(s, "%Y-%m-%d")
563 .map(|_| ())
564 .map_err(|_| {
565 BaseError::InvalidFieldType(
566 field_name.to_string(),
567 format!("日期格式无效,期望 YYYY-MM-DD,实际: {}", s),
568 )
569 })
570 } else {
571 Err(BaseError::InvalidFieldType(
572 field_name.to_string(),
573 format!("期望日期字符串类型,实际类型: {}", value_type_name(value)),
574 ))
575 }
576}
577
578fn validate_datetime(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
579 if let Some(s) = value.as_str() {
580 if chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%dT%H:%M:%S").is_ok()
583 || chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S").is_ok()
584 {
585 Ok(())
586 } else {
587 Err(BaseError::InvalidFieldType(
588 field_name.to_string(),
589 format!(
590 "日期时间格式无效,期望 YYYY-MM-DDTHH:MM:SS 或 YYYY-MM-DD HH:MM:SS,实际: {}",
591 s
592 ),
593 ))
594 }
595 } else {
596 Err(BaseError::InvalidFieldType(
597 field_name.to_string(),
598 format!(
599 "期望日期时间字符串类型,实际类型: {}",
600 value_type_name(value)
601 ),
602 ))
603 }
604}
605
606fn validate_timestamp(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
607 if let Some(ts) = value.as_i64() {
608 chrono::DateTime::<chrono::Utc>::from_timestamp_secs(ts)
609 .map(|_| ())
610 .ok_or_else(|| {
611 BaseError::InvalidFieldType(
612 field_name.to_string(),
613 format!("时间戳超出有效范围,实际: {}", ts),
614 )
615 })
616 } else {
617 Err(BaseError::InvalidFieldType(
618 field_name.to_string(),
619 format!("期望 Unix 时间戳整数,实际类型: {}", value_type_name(value)),
620 ))
621 }
622}
623
624#[cfg(test)]
625mod tests {
626 use super::*;
627
628 #[test]
629 fn test_field_type_display_name() {
630 assert_eq!(
631 FieldType::String { max_length: 50 }.display_name(),
632 "字符串"
633 );
634 assert_eq!(FieldType::Integer.display_name(), "整数");
635 assert_eq!(FieldType::BigInt.display_name(), "长整数");
636 assert_eq!(FieldType::Float.display_name(), "单精度浮点数");
637 assert_eq!(FieldType::Double.display_name(), "双精度浮点数");
638 assert_eq!(FieldType::Boolean.display_name(), "布尔值");
639 assert_eq!(FieldType::Date.display_name(), "日期");
640 assert_eq!(FieldType::DateTime.display_name(), "日期时间");
641 assert_eq!(FieldType::Timestamp.display_name(), "时间戳");
642 assert_eq!(FieldType::Json.display_name(), "JSON");
643 assert_eq!(FieldType::Text.display_name(), "文本");
644 assert_eq!(
645 FieldType::Enum {
646 values: vec!["a".to_string()]
647 }
648 .display_name(),
649 "枚举"
650 );
651 assert_eq!(
652 FieldType::ForeignKey {
653 table: "users".to_string(),
654 field: "id".to_string()
655 }
656 .display_name(),
657 "外键"
658 );
659 }
660
661 #[test]
662 fn test_is_numeric() {
663 assert!(FieldType::Integer.is_numeric());
664 assert!(FieldType::BigInt.is_numeric());
665 assert!(FieldType::Float.is_numeric());
666 assert!(FieldType::Double.is_numeric());
667 assert!(!FieldType::String { max_length: 50 }.is_numeric());
668 assert!(!FieldType::Boolean.is_numeric());
669 }
670
671 #[test]
672 fn test_is_temporal() {
673 assert!(FieldType::Date.is_temporal());
674 assert!(FieldType::DateTime.is_temporal());
675 assert!(FieldType::Timestamp.is_temporal());
676 assert!(!FieldType::String { max_length: 50 }.is_temporal());
677 assert!(!FieldType::Integer.is_temporal());
678 }
679
680 #[test]
681 fn test_is_text() {
682 assert!(FieldType::String { max_length: 50 }.is_text());
683 assert!(FieldType::Text.is_text());
684 assert!(!FieldType::Integer.is_text());
685 assert!(!FieldType::Boolean.is_text());
686 }
687
688 #[test]
689 fn test_field_type_equality() {
690 let type1 = FieldType::String { max_length: 50 };
691 let type2 = FieldType::String { max_length: 50 };
692 let type3 = FieldType::String { max_length: 100 };
693
694 assert_eq!(type1, type2);
695 assert_ne!(type1, type3);
696 }
697
698 #[test]
699 fn test_enum_type() {
700 let enum_type = FieldType::Enum {
701 values: vec![
702 "pending".to_string(),
703 "approved".to_string(),
704 "rejected".to_string(),
705 ],
706 };
707
708 assert_eq!(enum_type.display_name(), "枚举");
709 assert!(!enum_type.is_numeric());
710 assert!(!enum_type.is_temporal());
711 assert!(!enum_type.is_text());
712 }
713
714 #[test]
715 fn test_foreign_key_type() {
716 let fk_type = FieldType::ForeignKey {
717 table: "users".to_string(),
718 field: "id".to_string(),
719 };
720
721 assert_eq!(fk_type.display_name(), "外键");
722 assert!(!fk_type.is_numeric());
723 assert!(!fk_type.is_temporal());
724 assert!(!fk_type.is_text());
725 }
726
727 #[test]
730 fn test_validate_string_success() {
731 let field_type = FieldType::String { max_length: 10 };
732
733 assert!(field_type
735 .validate("name", &serde_json::json!("hello"))
736 .is_ok());
737 assert!(field_type.validate("name", &serde_json::json!("")).is_ok());
738
739 assert!(field_type
741 .validate("name", &serde_json::json!("1234567890"))
742 .is_ok());
743 }
744
745 #[test]
746 fn test_validate_string_too_long() {
747 let field_type = FieldType::String { max_length: 10 };
748
749 let result = field_type.validate("name", &serde_json::json!("this is too long"));
751 assert!(result.is_err());
752
753 assert!(
754 matches!(result, Err(BaseError::StringTooLong(ref field, 16, 10)) if field == "name"),
755 "期望 StringTooLong 错误,实际: {:?}",
756 result
757 );
758 }
759
760 #[test]
761 fn test_validate_string_invalid_type() {
762 let field_type = FieldType::String { max_length: 10 };
763
764 assert!(field_type
766 .validate("name", &serde_json::json!(123))
767 .is_err());
768 assert!(field_type
769 .validate("name", &serde_json::json!(true))
770 .is_err());
771 assert!(field_type
772 .validate("name", &serde_json::json!(null))
773 .is_err());
774 }
775
776 #[test]
777 fn test_validate_integer_success() {
778 let field_type = FieldType::Integer;
779
780 assert!(field_type.validate("age", &serde_json::json!(25)).is_ok());
782 assert!(field_type.validate("age", &serde_json::json!(0)).is_ok());
783 assert!(field_type.validate("age", &serde_json::json!(-100)).is_ok());
784
785 assert!(field_type
787 .validate("age", &serde_json::json!(i32::MAX))
788 .is_ok());
789 assert!(field_type
790 .validate("age", &serde_json::json!(i32::MIN))
791 .is_ok());
792 }
793
794 #[test]
795 fn test_validate_integer_out_of_range() {
796 let field_type = FieldType::Integer;
797
798 let result = field_type.validate("age", &serde_json::json!(i64::MAX));
800 assert!(result.is_err());
801 }
802
803 #[test]
804 fn test_validate_integer_invalid_type() {
805 let field_type = FieldType::Integer;
806
807 assert!(field_type
809 .validate("age", &serde_json::json!("not a number"))
810 .is_err());
811 assert!(field_type
812 .validate("age", &serde_json::json!(true))
813 .is_err());
814 assert!(field_type.validate("age", &serde_json::json!(3.5)).is_err());
815 }
816
817 #[test]
818 fn test_validate_bigint_success() {
819 let field_type = FieldType::BigInt;
820
821 assert!(field_type
823 .validate("id", &serde_json::json!(123456789))
824 .is_ok());
825 assert!(field_type
826 .validate("id", &serde_json::json!(i64::MAX))
827 .is_ok());
828 assert!(field_type
829 .validate("id", &serde_json::json!(i64::MIN))
830 .is_ok());
831 }
832
833 #[test]
834 fn test_validate_bigint_invalid_type() {
835 let field_type = FieldType::BigInt;
836
837 assert!(field_type
839 .validate("id", &serde_json::json!("not a number"))
840 .is_err());
841 assert!(field_type.validate("id", &serde_json::json!(3.5)).is_err());
842 }
843
844 #[test]
845 fn test_validate_float_success() {
846 let field_type = FieldType::Float;
847
848 assert!(field_type
850 .validate("price", &serde_json::json!(3.5))
851 .is_ok());
852 assert!(field_type
853 .validate("price", &serde_json::json!(0.0))
854 .is_ok());
855 assert!(field_type
856 .validate("price", &serde_json::json!(-1.5))
857 .is_ok());
858
859 assert!(field_type
861 .validate("price", &serde_json::json!(100))
862 .is_ok());
863 }
864
865 #[test]
866 fn test_validate_float_invalid_type() {
867 let field_type = FieldType::Float;
868
869 assert!(field_type
871 .validate("price", &serde_json::json!("not a number"))
872 .is_err());
873 assert!(field_type
874 .validate("price", &serde_json::json!(true))
875 .is_err());
876 }
877
878 #[test]
879 fn test_validate_double_success() {
880 let field_type = FieldType::Double;
881
882 assert!(field_type
884 .validate("amount", &serde_json::json!(123.456))
885 .is_ok());
886 assert!(field_type
887 .validate("amount", &serde_json::json!(0.0))
888 .is_ok());
889 assert!(field_type
890 .validate("amount", &serde_json::json!(100))
891 .is_ok());
892 }
893
894 #[test]
895 fn test_validate_double_invalid_type() {
896 let field_type = FieldType::Double;
897
898 assert!(field_type
900 .validate("amount", &serde_json::json!("not a number"))
901 .is_err());
902 assert!(field_type
903 .validate("amount", &serde_json::json!(true))
904 .is_err());
905 }
906
907 #[test]
908 fn test_validate_boolean_success() {
909 let field_type = FieldType::Boolean;
910
911 assert!(field_type
913 .validate("active", &serde_json::json!(true))
914 .is_ok());
915 assert!(field_type
916 .validate("active", &serde_json::json!(false))
917 .is_ok());
918 }
919
920 #[test]
921 fn test_validate_boolean_invalid_type() {
922 let field_type = FieldType::Boolean;
923
924 assert!(field_type
926 .validate("active", &serde_json::json!("true"))
927 .is_err());
928 assert!(field_type
929 .validate("active", &serde_json::json!(1))
930 .is_err());
931 assert!(field_type
932 .validate("active", &serde_json::json!(0))
933 .is_err());
934 }
935
936 #[test]
937 fn test_validate_date_success() {
938 let field_type = FieldType::Date;
939
940 assert!(field_type
941 .validate("birthday", &serde_json::json!("2026-05-27"))
942 .is_ok());
943 }
944
945 #[test]
946 fn test_validate_date_invalid_format() {
947 let field_type = FieldType::Date;
948
949 let result = field_type.validate("birthday", &serde_json::json!("2026/05/27"));
950 assert!(result.is_err());
951 assert!(
952 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
953 );
954 }
955
956 #[test]
957 fn test_validate_date_invalid_type() {
958 let field_type = FieldType::Date;
959
960 let result = field_type.validate("birthday", &serde_json::json!(20260527));
961 assert!(result.is_err());
962 assert!(
963 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
964 );
965 }
966
967 #[test]
968 fn test_validate_datetime_success() {
969 let field_type = FieldType::DateTime;
970
971 assert!(field_type
972 .validate("created_at", &serde_json::json!("2026-05-27 13:45:30"))
973 .is_ok());
974 }
975
976 #[test]
977 fn test_validate_datetime_invalid_format() {
978 let field_type = FieldType::DateTime;
979
980 assert!(field_type
982 .validate("created_at", &serde_json::json!("2026-05-27T13:45:30"))
983 .is_ok());
984
985 let result = field_type.validate("created_at", &serde_json::json!("2026/05/27 13:45:30"));
987 assert!(result.is_err());
988 assert!(
989 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
990 );
991 }
992
993 #[test]
994 fn test_validate_datetime_roundtrip_from_dynamic_row() {
995 let field_type = FieldType::DateTime;
998 let read_back = serde_json::json!("2026-05-27T13:45:30");
999 assert!(field_type.validate("created_at", &read_back).is_ok());
1000 }
1001
1002 #[test]
1003 fn test_validate_timestamp_success() {
1004 let field_type = FieldType::Timestamp;
1005
1006 assert!(field_type
1007 .validate("created_at", &serde_json::json!(1_764_221_130_i64))
1008 .is_ok());
1009 }
1010
1011 #[test]
1012 fn test_validate_timestamp_invalid_type() {
1013 let field_type = FieldType::Timestamp;
1014
1015 let result = field_type.validate("created_at", &serde_json::json!("2026-05-27 13:45:30"));
1016 assert!(result.is_err());
1017 assert!(
1018 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
1019 );
1020 }
1021
1022 #[test]
1023 fn test_validate_text_success() {
1024 let field_type = FieldType::Text;
1025
1026 assert!(field_type
1028 .validate("content", &serde_json::json!("hello"))
1029 .is_ok());
1030 assert!(field_type
1031 .validate("content", &serde_json::json!("a".repeat(100_000)))
1032 .is_ok());
1033 assert!(field_type
1034 .validate("content", &serde_json::json!(""))
1035 .is_ok());
1036 }
1037
1038 #[test]
1039 fn test_validate_text_invalid_type() {
1040 let field_type = FieldType::Text;
1041
1042 let result = field_type.validate("content", &serde_json::json!(123));
1044 assert!(
1045 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "content")
1046 );
1047 assert!(field_type
1048 .validate("content", &serde_json::json!(true))
1049 .is_err());
1050 assert!(field_type
1051 .validate("content", &serde_json::json!(null))
1052 .is_err());
1053 }
1054
1055 #[test]
1056 fn test_validate_foreign_key_not_enforced() {
1057 let field_type = FieldType::ForeignKey {
1058 table: "users".to_string(),
1059 field: "id".to_string(),
1060 };
1061
1062 assert!(field_type
1064 .validate("user_id", &serde_json::json!(1))
1065 .is_ok());
1066 assert!(field_type
1067 .validate("user_id", &serde_json::json!("uuid-string"))
1068 .is_ok());
1069 assert!(field_type
1070 .validate("user_id", &serde_json::json!(null))
1071 .is_ok());
1072 }
1073
1074 #[test]
1075 fn test_validate_enum_success() {
1076 let field_type = FieldType::Enum {
1077 values: vec![
1078 "pending".to_string(),
1079 "approved".to_string(),
1080 "rejected".to_string(),
1081 ],
1082 };
1083
1084 assert!(field_type
1086 .validate("status", &serde_json::json!("pending"))
1087 .is_ok());
1088 assert!(field_type
1089 .validate("status", &serde_json::json!("approved"))
1090 .is_ok());
1091 assert!(field_type
1092 .validate("status", &serde_json::json!("rejected"))
1093 .is_ok());
1094 }
1095
1096 #[test]
1097 fn test_validate_enum_invalid_value() {
1098 let field_type = FieldType::Enum {
1099 values: vec![
1100 "pending".to_string(),
1101 "approved".to_string(),
1102 "rejected".to_string(),
1103 ],
1104 };
1105
1106 let result = field_type.validate("status", &serde_json::json!("invalid"));
1108 assert!(result.is_err());
1109
1110 assert!(
1111 matches!(result, Err(BaseError::InvalidEnumValue(ref field, ref value)) if field == "status" && value == "invalid"),
1112 "期望 InvalidEnumValue 错误,实际: {:?}",
1113 result
1114 );
1115 }
1116
1117 #[test]
1118 fn test_validate_enum_invalid_type() {
1119 let field_type = FieldType::Enum {
1120 values: vec!["pending".to_string()],
1121 };
1122
1123 assert!(field_type
1125 .validate("status", &serde_json::json!(123))
1126 .is_err());
1127 assert!(field_type
1128 .validate("status", &serde_json::json!(true))
1129 .is_err());
1130 }
1131
1132 #[test]
1133 fn test_validate_json_success() {
1134 let field_type = FieldType::Json;
1135
1136 assert!(field_type
1138 .validate("data", &serde_json::json!({"key": "value"}))
1139 .is_ok());
1140
1141 assert!(field_type
1143 .validate("data", &serde_json::json!([1, 2, 3]))
1144 .is_ok());
1145
1146 assert!(field_type
1148 .validate("data", &serde_json::json!("{\"key\": \"value\"}"))
1149 .is_ok());
1150 assert!(field_type
1151 .validate("data", &serde_json::json!("[1, 2, 3]"))
1152 .is_ok());
1153 }
1154
1155 #[test]
1156 fn test_validate_json_invalid_format() {
1157 let field_type = FieldType::Json;
1158
1159 let result = field_type.validate("data", &serde_json::json!("not a json"));
1161 assert!(result.is_err());
1162
1163 assert!(
1164 matches!(result, Err(BaseError::InvalidJsonFormat(ref field, _)) if field == "data"),
1165 "期望 InvalidJsonFormat 错误,实际: {:?}",
1166 result
1167 );
1168 }
1169
1170 #[test]
1171 fn test_validate_json_invalid_type() {
1172 let field_type = FieldType::Json;
1173
1174 assert!(field_type
1176 .validate("data", &serde_json::json!(123))
1177 .is_err());
1178 assert!(field_type
1179 .validate("data", &serde_json::json!(true))
1180 .is_err());
1181 assert!(field_type
1182 .validate("data", &serde_json::json!(null))
1183 .is_err());
1184 }
1185}