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)]
53#[non_exhaustive]
54pub enum FieldType {
55 String {
71 max_length: usize,
73 },
74
75 Integer,
87
88 BigInt,
100
101 Float,
113
114 Double,
126
127 Decimal {
129 precision: u8,
131 scale: u8,
133 },
134
135 Boolean,
147
148 Date,
160
161 DateTime,
173
174 Timestamp,
186
187 Json,
199
200 Text,
212
213 Enum {
235 values: Vec<String>,
237 },
238}
239
240impl FieldType {
241 pub fn display_name(&self) -> &str {
259 match self {
260 FieldType::String { .. } => "字符串",
261 FieldType::Integer => "整数",
262 FieldType::BigInt => "长整数",
263 FieldType::Float => "单精度浮点数",
264 FieldType::Double => "双精度浮点数",
265 FieldType::Decimal { .. } => "定点小数",
266 FieldType::Boolean => "布尔值",
267 FieldType::Date => "日期",
268 FieldType::DateTime => "日期时间",
269 FieldType::Timestamp => "时间戳",
270 FieldType::Json => "JSON",
271 FieldType::Text => "文本",
272 FieldType::Enum { .. } => "枚举",
273 }
274 }
275
276 pub fn is_numeric(&self) -> bool {
292 matches!(
293 self,
294 FieldType::Integer
295 | FieldType::BigInt
296 | FieldType::Float
297 | FieldType::Double
298 | FieldType::Decimal { .. }
299 )
300 }
301
302 pub fn is_temporal(&self) -> bool {
318 matches!(
319 self,
320 FieldType::Date | FieldType::DateTime | FieldType::Timestamp
321 )
322 }
323
324 pub fn is_text(&self) -> bool {
340 matches!(self, FieldType::String { .. } | FieldType::Text)
341 }
342
343 pub fn validate(&self, field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
369 match self {
370 FieldType::String { max_length } => {
372 if let Some(s) = value.as_str() {
373 let len = s.chars().count();
374 if len > *max_length {
375 return Err(BaseError::StringTooLong(
376 field_name.to_string(),
377 len,
378 *max_length,
379 ));
380 }
381 Ok(())
382 } else {
383 Err(BaseError::InvalidFieldType(
384 field_name.to_string(),
385 format!("期望字符串类型,实际类型: {}", value_type_name(value)),
386 ))
387 }
388 }
389
390 FieldType::Integer => {
392 if value.is_i64() || value.is_u64() {
393 if let Some(n) = value.as_i64() {
395 if n >= i32::MIN as i64 && n <= i32::MAX as i64 {
396 return Ok(());
397 }
398 }
399 Err(BaseError::InvalidFieldType(
400 field_name.to_string(),
401 "整数值超出 i32 范围".to_string(),
402 ))
403 } else {
404 Err(BaseError::InvalidFieldType(
405 field_name.to_string(),
406 format!("期望整数类型,实际类型: {}", value_type_name(value)),
407 ))
408 }
409 }
410
411 FieldType::BigInt => {
413 if value.as_i64().is_some() {
414 Ok(())
415 } else {
416 Err(BaseError::InvalidFieldType(
417 field_name.to_string(),
418 format!("期望 i64 范围内的长整数,实际值: {}", value),
419 ))
420 }
421 }
422
423 FieldType::Float => {
425 if value.is_f64() || value.is_i64() || value.is_u64() {
426 if let Some(n) = value.as_f64() {
428 if n.is_finite() && n.abs() <= f32::MAX as f64 {
429 return Ok(());
430 }
431 }
432 Err(BaseError::InvalidFieldType(
433 field_name.to_string(),
434 "浮点数值超出 f32 范围".to_string(),
435 ))
436 } else {
437 Err(BaseError::InvalidFieldType(
438 field_name.to_string(),
439 format!("期望浮点数类型,实际类型: {}", value_type_name(value)),
440 ))
441 }
442 }
443
444 FieldType::Double => {
446 if value.is_f64() || value.is_i64() || value.is_u64() {
447 Ok(())
448 } else {
449 Err(BaseError::InvalidFieldType(
450 field_name.to_string(),
451 format!("期望双精度浮点数类型,实际类型: {}", value_type_name(value)),
452 ))
453 }
454 }
455
456 FieldType::Decimal { precision, scale } => {
457 validate_decimal(field_name, value, *precision, *scale)
458 }
459
460 FieldType::Boolean => {
462 if value.is_boolean() {
463 Ok(())
464 } else {
465 Err(BaseError::InvalidFieldType(
466 field_name.to_string(),
467 format!("期望布尔类型,实际类型: {}", value_type_name(value)),
468 ))
469 }
470 }
471
472 FieldType::Date => validate_date(field_name, value),
474
475 FieldType::DateTime => validate_datetime(field_name, value),
477
478 FieldType::Timestamp => validate_timestamp(field_name, value),
480
481 FieldType::Enum { values } => {
483 if let Some(s) = value.as_str() {
484 if values.contains(&s.to_string()) {
485 Ok(())
486 } else {
487 Err(BaseError::InvalidEnumValue(
488 field_name.to_string(),
489 s.to_string(),
490 ))
491 }
492 } else {
493 Err(BaseError::InvalidFieldType(
494 field_name.to_string(),
495 format!(
496 "期望字符串类型的枚举值,实际类型: {}",
497 value_type_name(value)
498 ),
499 ))
500 }
501 }
502
503 FieldType::Json => {
505 if value.is_object() || value.is_array() {
506 Ok(())
507 } else {
508 Err(BaseError::InvalidFieldType(
509 field_name.to_string(),
510 format!("期望 JSON 对象或数组,实际类型: {}", value_type_name(value)),
511 ))
512 }
513 }
514
515 FieldType::Text => {
517 if value.as_str().is_some() {
518 Ok(())
519 } else {
520 Err(BaseError::InvalidFieldType(
521 field_name.to_string(),
522 format!("期望文本字符串类型,实际类型: {}", value_type_name(value)),
523 ))
524 }
525 }
526 }
527 }
528}
529
530fn validate_decimal(
531 field_name: &str,
532 value: &serde_json::Value,
533 precision: u8,
534 scale: u8,
535) -> Result<(), BaseError> {
536 let text = match value {
537 serde_json::Value::String(value) => std::borrow::Cow::Borrowed(value.as_str()),
538 serde_json::Value::Number(value) => std::borrow::Cow::Owned(value.to_string()),
539 _ => {
540 return Err(BaseError::InvalidFieldType(
541 field_name.to_string(),
542 format!(
543 "期望十进制数字或字符串,实际类型: {}",
544 value_type_name(value)
545 ),
546 ));
547 }
548 };
549 let unsigned = text.strip_prefix('-').unwrap_or(text.as_ref());
550 let (integer, fraction) = unsigned.split_once('.').unwrap_or((unsigned, ""));
551 let digits = integer.len() + fraction.len();
552 let valid = !integer.is_empty()
553 && integer.bytes().all(|byte| byte.is_ascii_digit())
554 && fraction.bytes().all(|byte| byte.is_ascii_digit())
555 && digits <= usize::from(precision)
556 && fraction.len() <= usize::from(scale);
557 if valid {
558 Ok(())
559 } else {
560 Err(BaseError::InvalidFieldType(
561 field_name.to_string(),
562 format!("值 {text} 不符合 DECIMAL({precision}, {scale})"),
563 ))
564 }
565}
566
567fn validate_date(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
568 if let Some(s) = value.as_str() {
569 chrono::NaiveDate::parse_from_str(s, "%Y-%m-%d")
570 .map(|_| ())
571 .map_err(|_| {
572 BaseError::InvalidFieldType(
573 field_name.to_string(),
574 format!("日期格式无效,期望 YYYY-MM-DD,实际: {}", s),
575 )
576 })
577 } else {
578 Err(BaseError::InvalidFieldType(
579 field_name.to_string(),
580 format!("期望日期字符串类型,实际类型: {}", value_type_name(value)),
581 ))
582 }
583}
584
585fn validate_datetime(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
586 if let Some(s) = value.as_str() {
587 chrono::DateTime::parse_from_rfc3339(s)
588 .map(|_| ())
589 .map_err(|_| {
590 BaseError::InvalidFieldType(
591 field_name.to_string(),
592 format!("日期时间格式无效,期望 RFC 3339,实际: {s}"),
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 }
652
653 #[test]
654 fn test_is_numeric() {
655 assert!(FieldType::Integer.is_numeric());
656 assert!(FieldType::BigInt.is_numeric());
657 assert!(FieldType::Float.is_numeric());
658 assert!(FieldType::Double.is_numeric());
659 assert!(!FieldType::String { max_length: 50 }.is_numeric());
660 assert!(!FieldType::Boolean.is_numeric());
661 }
662
663 #[test]
664 fn test_is_temporal() {
665 assert!(FieldType::Date.is_temporal());
666 assert!(FieldType::DateTime.is_temporal());
667 assert!(FieldType::Timestamp.is_temporal());
668 assert!(!FieldType::String { max_length: 50 }.is_temporal());
669 assert!(!FieldType::Integer.is_temporal());
670 }
671
672 #[test]
673 fn test_is_text() {
674 assert!(FieldType::String { max_length: 50 }.is_text());
675 assert!(FieldType::Text.is_text());
676 assert!(!FieldType::Integer.is_text());
677 assert!(!FieldType::Boolean.is_text());
678 }
679
680 #[test]
681 fn test_field_type_equality() {
682 let type1 = FieldType::String { max_length: 50 };
683 let type2 = FieldType::String { max_length: 50 };
684 let type3 = FieldType::String { max_length: 100 };
685
686 assert_eq!(type1, type2);
687 assert_ne!(type1, type3);
688 }
689
690 #[test]
691 fn test_enum_type() {
692 let enum_type = FieldType::Enum {
693 values: vec![
694 "pending".to_string(),
695 "approved".to_string(),
696 "rejected".to_string(),
697 ],
698 };
699
700 assert_eq!(enum_type.display_name(), "枚举");
701 assert!(!enum_type.is_numeric());
702 assert!(!enum_type.is_temporal());
703 assert!(!enum_type.is_text());
704 }
705
706 #[test]
709 fn test_validate_string_success() {
710 let field_type = FieldType::String { max_length: 10 };
711
712 assert!(field_type
714 .validate("name", &serde_json::json!("hello"))
715 .is_ok());
716 assert!(field_type.validate("name", &serde_json::json!("")).is_ok());
717
718 assert!(field_type
720 .validate("name", &serde_json::json!("1234567890"))
721 .is_ok());
722 }
723
724 #[test]
725 fn test_validate_string_too_long() {
726 let field_type = FieldType::String { max_length: 10 };
727
728 let result = field_type.validate("name", &serde_json::json!("this is too long"));
730 assert!(result.is_err());
731
732 assert!(
733 matches!(result, Err(BaseError::StringTooLong(ref field, 16, 10)) if field == "name"),
734 "期望 StringTooLong 错误,实际: {:?}",
735 result
736 );
737 }
738
739 #[test]
740 fn test_validate_string_invalid_type() {
741 let field_type = FieldType::String { max_length: 10 };
742
743 assert!(field_type
745 .validate("name", &serde_json::json!(123))
746 .is_err());
747 assert!(field_type
748 .validate("name", &serde_json::json!(true))
749 .is_err());
750 assert!(field_type
751 .validate("name", &serde_json::json!(null))
752 .is_err());
753 }
754
755 #[test]
756 fn test_validate_integer_success() {
757 let field_type = FieldType::Integer;
758
759 assert!(field_type.validate("age", &serde_json::json!(25)).is_ok());
761 assert!(field_type.validate("age", &serde_json::json!(0)).is_ok());
762 assert!(field_type.validate("age", &serde_json::json!(-100)).is_ok());
763
764 assert!(field_type
766 .validate("age", &serde_json::json!(i32::MAX))
767 .is_ok());
768 assert!(field_type
769 .validate("age", &serde_json::json!(i32::MIN))
770 .is_ok());
771 }
772
773 #[test]
774 fn test_validate_integer_out_of_range() {
775 let field_type = FieldType::Integer;
776
777 let result = field_type.validate("age", &serde_json::json!(i64::MAX));
779 assert!(result.is_err());
780 }
781
782 #[test]
783 fn test_validate_integer_invalid_type() {
784 let field_type = FieldType::Integer;
785
786 assert!(field_type
788 .validate("age", &serde_json::json!("not a number"))
789 .is_err());
790 assert!(field_type
791 .validate("age", &serde_json::json!(true))
792 .is_err());
793 assert!(field_type.validate("age", &serde_json::json!(3.5)).is_err());
794 }
795
796 #[test]
797 fn test_validate_bigint_success() {
798 let field_type = FieldType::BigInt;
799
800 assert!(field_type
802 .validate("id", &serde_json::json!(123456789))
803 .is_ok());
804 assert!(field_type
805 .validate("id", &serde_json::json!(i64::MAX))
806 .is_ok());
807 assert!(field_type
808 .validate("id", &serde_json::json!(i64::MIN))
809 .is_ok());
810 }
811
812 #[test]
813 fn test_validate_bigint_invalid_type() {
814 let field_type = FieldType::BigInt;
815
816 assert!(field_type
818 .validate("id", &serde_json::json!("not a number"))
819 .is_err());
820 assert!(field_type.validate("id", &serde_json::json!(3.5)).is_err());
821 assert!(field_type
822 .validate("id", &serde_json::json!(u64::MAX))
823 .is_err());
824 }
825
826 #[test]
827 fn test_validate_float_success() {
828 let field_type = FieldType::Float;
829
830 assert!(field_type
832 .validate("price", &serde_json::json!(3.5))
833 .is_ok());
834 assert!(field_type
835 .validate("price", &serde_json::json!(0.0))
836 .is_ok());
837 assert!(field_type
838 .validate("price", &serde_json::json!(-1.5))
839 .is_ok());
840
841 assert!(field_type
843 .validate("price", &serde_json::json!(100))
844 .is_ok());
845 }
846
847 #[test]
848 fn test_validate_float_invalid_type() {
849 let field_type = FieldType::Float;
850
851 assert!(field_type
853 .validate("price", &serde_json::json!("not a number"))
854 .is_err());
855 assert!(field_type
856 .validate("price", &serde_json::json!(true))
857 .is_err());
858 }
859
860 #[test]
861 fn test_validate_double_success() {
862 let field_type = FieldType::Double;
863
864 assert!(field_type
866 .validate("amount", &serde_json::json!(123.456))
867 .is_ok());
868 assert!(field_type
869 .validate("amount", &serde_json::json!(0.0))
870 .is_ok());
871 assert!(field_type
872 .validate("amount", &serde_json::json!(100))
873 .is_ok());
874 }
875
876 #[test]
877 fn test_validate_double_invalid_type() {
878 let field_type = FieldType::Double;
879
880 assert!(field_type
882 .validate("amount", &serde_json::json!("not a number"))
883 .is_err());
884 assert!(field_type
885 .validate("amount", &serde_json::json!(true))
886 .is_err());
887 }
888
889 #[test]
890 fn test_validate_decimal_preserves_fixed_point_contract() {
891 let field_type = FieldType::Decimal {
892 precision: 8,
893 scale: 2,
894 };
895 assert!(field_type
896 .validate("amount", &serde_json::json!("123456.78"))
897 .is_ok());
898 assert!(field_type
899 .validate("amount", &serde_json::json!("1234567.89"))
900 .is_err());
901 assert!(field_type
902 .validate("amount", &serde_json::json!("1.234"))
903 .is_err());
904 assert!(field_type
905 .validate("amount", &serde_json::json!("not-a-number"))
906 .is_err());
907 }
908
909 #[test]
910 fn test_validate_boolean_success() {
911 let field_type = FieldType::Boolean;
912
913 assert!(field_type
915 .validate("active", &serde_json::json!(true))
916 .is_ok());
917 assert!(field_type
918 .validate("active", &serde_json::json!(false))
919 .is_ok());
920 }
921
922 #[test]
923 fn test_validate_boolean_invalid_type() {
924 let field_type = FieldType::Boolean;
925
926 assert!(field_type
928 .validate("active", &serde_json::json!("true"))
929 .is_err());
930 assert!(field_type
931 .validate("active", &serde_json::json!(1))
932 .is_err());
933 assert!(field_type
934 .validate("active", &serde_json::json!(0))
935 .is_err());
936 }
937
938 #[test]
939 fn test_validate_date_success() {
940 let field_type = FieldType::Date;
941
942 assert!(field_type
943 .validate("birthday", &serde_json::json!("2026-05-27"))
944 .is_ok());
945 }
946
947 #[test]
948 fn test_validate_date_invalid_format() {
949 let field_type = FieldType::Date;
950
951 let result = field_type.validate("birthday", &serde_json::json!("2026/05/27"));
952 assert!(result.is_err());
953 assert!(
954 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
955 );
956 }
957
958 #[test]
959 fn test_validate_date_invalid_type() {
960 let field_type = FieldType::Date;
961
962 let result = field_type.validate("birthday", &serde_json::json!(20260527));
963 assert!(result.is_err());
964 assert!(
965 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
966 );
967 }
968
969 #[test]
970 fn test_validate_datetime_success() {
971 let field_type = FieldType::DateTime;
972
973 assert!(field_type
974 .validate(
975 "created_at",
976 &serde_json::json!("2026-05-27T13:45:30+08:00"),
977 )
978 .is_ok());
979 assert!(field_type
980 .validate("created_at", &serde_json::json!("2026-05-27T05:45:30Z"))
981 .is_ok());
982 }
983
984 #[test]
985 fn test_validate_datetime_invalid_format() {
986 let field_type = FieldType::DateTime;
987
988 assert!(field_type
990 .validate("created_at", &serde_json::json!("2026-05-27T13:45:30"))
991 .is_err());
992 assert!(field_type
993 .validate("created_at", &serde_json::json!("2026-05-27 13:45:30"))
994 .is_err());
995
996 let result = field_type.validate("created_at", &serde_json::json!("2026/05/27 13:45:30"));
998 assert!(result.is_err());
999 assert!(
1000 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
1001 );
1002 }
1003
1004 #[test]
1005 fn test_validate_datetime_matches_json_schema_date_time_format() {
1006 let field_type = FieldType::DateTime;
1008 let value = serde_json::json!("2026-05-27T13:45:30.123+08:00");
1009 assert!(field_type.validate("created_at", &value).is_ok());
1010 }
1011
1012 #[test]
1013 fn test_validate_timestamp_success() {
1014 let field_type = FieldType::Timestamp;
1015
1016 assert!(field_type
1017 .validate("created_at", &serde_json::json!(1_764_221_130_i64))
1018 .is_ok());
1019 }
1020
1021 #[test]
1022 fn test_validate_timestamp_invalid_type() {
1023 let field_type = FieldType::Timestamp;
1024
1025 let result = field_type.validate("created_at", &serde_json::json!("2026-05-27 13:45:30"));
1026 assert!(result.is_err());
1027 assert!(
1028 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
1029 );
1030 }
1031
1032 #[test]
1033 fn test_validate_text_success() {
1034 let field_type = FieldType::Text;
1035
1036 assert!(field_type
1038 .validate("content", &serde_json::json!("hello"))
1039 .is_ok());
1040 assert!(field_type
1041 .validate("content", &serde_json::json!("a".repeat(100_000)))
1042 .is_ok());
1043 assert!(field_type
1044 .validate("content", &serde_json::json!(""))
1045 .is_ok());
1046 }
1047
1048 #[test]
1049 fn test_validate_text_invalid_type() {
1050 let field_type = FieldType::Text;
1051
1052 let result = field_type.validate("content", &serde_json::json!(123));
1054 assert!(
1055 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "content")
1056 );
1057 assert!(field_type
1058 .validate("content", &serde_json::json!(true))
1059 .is_err());
1060 assert!(field_type
1061 .validate("content", &serde_json::json!(null))
1062 .is_err());
1063 }
1064
1065 #[test]
1066 fn test_validate_enum_success() {
1067 let field_type = FieldType::Enum {
1068 values: vec![
1069 "pending".to_string(),
1070 "approved".to_string(),
1071 "rejected".to_string(),
1072 ],
1073 };
1074
1075 assert!(field_type
1077 .validate("status", &serde_json::json!("pending"))
1078 .is_ok());
1079 assert!(field_type
1080 .validate("status", &serde_json::json!("approved"))
1081 .is_ok());
1082 assert!(field_type
1083 .validate("status", &serde_json::json!("rejected"))
1084 .is_ok());
1085 }
1086
1087 #[test]
1088 fn test_validate_enum_invalid_value() {
1089 let field_type = FieldType::Enum {
1090 values: vec![
1091 "pending".to_string(),
1092 "approved".to_string(),
1093 "rejected".to_string(),
1094 ],
1095 };
1096
1097 let result = field_type.validate("status", &serde_json::json!("invalid"));
1099 assert!(result.is_err());
1100
1101 assert!(
1102 matches!(result, Err(BaseError::InvalidEnumValue(ref field, ref value)) if field == "status" && value == "invalid"),
1103 "期望 InvalidEnumValue 错误,实际: {:?}",
1104 result
1105 );
1106 }
1107
1108 #[test]
1109 fn test_validate_enum_invalid_type() {
1110 let field_type = FieldType::Enum {
1111 values: vec!["pending".to_string()],
1112 };
1113
1114 assert!(field_type
1116 .validate("status", &serde_json::json!(123))
1117 .is_err());
1118 assert!(field_type
1119 .validate("status", &serde_json::json!(true))
1120 .is_err());
1121 }
1122
1123 #[test]
1124 fn test_validate_json_success() {
1125 let field_type = FieldType::Json;
1126
1127 assert!(field_type
1129 .validate("data", &serde_json::json!({"key": "value"}))
1130 .is_ok());
1131
1132 assert!(field_type
1134 .validate("data", &serde_json::json!([1, 2, 3]))
1135 .is_ok());
1136 }
1137
1138 #[test]
1139 fn test_validate_json_invalid_format() {
1140 let field_type = FieldType::Json;
1141
1142 let result = field_type.validate("data", &serde_json::json!("not a json"));
1144 assert!(result.is_err());
1145
1146 assert!(field_type
1147 .validate("data", &serde_json::json!("{\"key\": \"value\"}"))
1148 .is_err());
1149 assert!(field_type
1150 .validate("data", &serde_json::json!("[1, 2, 3]"))
1151 .is_err());
1152
1153 assert!(
1154 matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "data"),
1155 "期望 InvalidFieldType 错误,实际: {:?}",
1156 result
1157 );
1158 }
1159
1160 #[test]
1161 fn test_validate_json_invalid_type() {
1162 let field_type = FieldType::Json;
1163
1164 assert!(field_type
1166 .validate("data", &serde_json::json!(123))
1167 .is_err());
1168 assert!(field_type
1169 .validate("data", &serde_json::json!(true))
1170 .is_err());
1171 assert!(field_type
1172 .validate("data", &serde_json::json!(null))
1173 .is_err());
1174 }
1175}