Skip to main content

rip_settings/
validation.rs

1use 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}