rip_settings/
validation.rs1use crate::field::ValidationRules;
2
3#[derive(Clone, Debug, PartialEq)]
4pub enum ValidationResult {
5 Valid,
6 Invalid(String),
7}
8
9impl ValidationResult {
10 #[must_use]
11 pub fn is_valid(&self) -> bool {
12 matches!(self, Self::Valid)
13 }
14}
15
16pub fn validate_value(value: &serde_json::Value, rules: &ValidationRules) -> ValidationResult {
17 if rules.required {
18 let is_empty = match value {
19 serde_json::Value::Null => true,
20 serde_json::Value::String(s) => s.trim().is_empty(),
21 serde_json::Value::Array(a) => a.is_empty(),
22 _ => false,
23 };
24 if is_empty {
25 return ValidationResult::Invalid(
26 rules
27 .error_message
28 .clone()
29 .unwrap_or_else(|| "This field is required".into()),
30 );
31 }
32 }
33
34 if let Some((min, max)) = rules.range {
35 if let Some(num) = value.as_f64() {
36 if num < min || num > max {
37 return ValidationResult::Invalid(
38 rules
39 .error_message
40 .clone()
41 .unwrap_or_else(|| format!("Value must be between {} and {}", min, max)),
42 );
43 }
44 }
45 }
46
47 if let Some((min_len, max_len)) = rules.length {
48 if let Some(s) = value.as_str() {
49 let len = s.chars().count();
50 if len < min_len || len > max_len {
51 return ValidationResult::Invalid(rules.error_message.clone().unwrap_or_else(
52 || format!("Length must be between {} and {}", min_len, max_len),
53 ));
54 }
55 }
56 }
57
58 if let Some(ref pattern) = rules.pattern {
59 if let Some(s) = value.as_str() {
60 match regex::Regex::new(pattern) {
61 Ok(re) => {
62 if !re.is_match(s) {
63 return ValidationResult::Invalid(
64 rules
65 .error_message
66 .clone()
67 .unwrap_or_else(|| "Value does not match required pattern".into()),
68 );
69 }
70 }
71 Err(e) => {
72 return ValidationResult::Invalid(format!("Invalid validation pattern: {}", e));
73 }
74 }
75 }
76 }
77
78 ValidationResult::Valid
79}
80
81#[cfg(test)]
82mod tests {
83 use super::*;
84
85 #[test]
86 fn test_required_validation() {
87 let rules = ValidationRules {
88 required: true,
89 ..Default::default()
90 };
91
92 assert_eq!(
93 validate_value(&serde_json::Value::Null, &rules),
94 ValidationResult::Invalid("This field is required".into())
95 );
96
97 assert_eq!(
98 validate_value(&serde_json::json!("hello"), &rules),
99 ValidationResult::Valid
100 );
101
102 assert_eq!(
103 validate_value(&serde_json::json!(""), &rules),
104 ValidationResult::Invalid("This field is required".into())
105 );
106 }
107
108 #[test]
109 fn test_range_validation() {
110 let rules = ValidationRules {
111 range: Some((0.0, 100.0)),
112 ..Default::default()
113 };
114
115 assert_eq!(
116 validate_value(&serde_json::json!(50), &rules),
117 ValidationResult::Valid
118 );
119 assert_eq!(
120 validate_value(&serde_json::json!(150), &rules),
121 ValidationResult::Invalid("Value must be between 0 and 100".into())
122 );
123 assert_eq!(
124 validate_value(&serde_json::json!(-1), &rules),
125 ValidationResult::Invalid("Value must be between 0 and 100".into())
126 );
127 }
128
129 #[test]
130 fn test_length_validation_char_count() {
131 let rules = ValidationRules {
132 length: Some((3, 10)),
133 ..Default::default()
134 };
135
136 assert_eq!(
137 validate_value(&serde_json::json!("hello"), &rules),
138 ValidationResult::Valid
139 );
140 assert_eq!(
141 validate_value(&serde_json::json!("hi"), &rules),
142 ValidationResult::Invalid("Length must be between 3 and 10".into())
143 );
144 assert_eq!(
145 validate_value(&serde_json::json!("🎉"), &rules),
146 ValidationResult::Invalid("Length must be between 3 and 10".into())
147 );
148 assert_eq!(
149 validate_value(&serde_json::json!("café"), &rules),
150 ValidationResult::Valid
151 );
152 }
153
154 #[test]
155 fn test_pattern_validation() {
156 let rules = ValidationRules {
157 pattern: Some(r"^\d{3}-\d{4}$".into()),
158 ..Default::default()
159 };
160
161 assert_eq!(
162 validate_value(&serde_json::json!("123-4567"), &rules),
163 ValidationResult::Valid
164 );
165 assert_eq!(
166 validate_value(&serde_json::json!("abc"), &rules),
167 ValidationResult::Invalid("Value does not match required pattern".into())
168 );
169 }
170
171 #[test]
172 fn test_custom_error_message() {
173 let rules = ValidationRules {
174 range: Some((0.0, 10.0)),
175 error_message: Some("Custom error".into()),
176 ..Default::default()
177 };
178
179 assert_eq!(
180 validate_value(&serde_json::json!(20), &rules),
181 ValidationResult::Invalid("Custom error".into())
182 );
183 }
184}