avocado_schema/core/constraint/number/
minimum.rs

1use crate::core::constraint::Constraint;
2use crate::core::value::FieldValue;
3use anyhow::{anyhow, Result};
4
5#[derive(Debug)]
6pub struct Minimum<T: Copy> {
7    pub min_val: T,
8}
9
10impl Constraint for Minimum<i64> {
11    fn validate(&self, val: &FieldValue) -> Result<()> {
12        match val {
13            FieldValue::Integer(v) if (*v < self.min_val) => Err(anyhow!(format!(
14                "value {} is less then {} ({})",
15                v, self.min_val, "Minimum"
16            ))),
17            _ => Ok(()),
18        }
19    }
20}
21
22impl Constraint for Minimum<u64> {
23    fn validate(&self, val: &FieldValue) -> Result<()> {
24        match val {
25            FieldValue::UInteger(v) if (*v < self.min_val) => Err(anyhow!(format!(
26                "value {} is less then {} ({})",
27                v, self.min_val, "Minimum"
28            ))),
29            _ => Ok(()),
30        }
31    }
32}
33
34impl Constraint for Minimum<f64> {
35    fn validate(&self, val: &FieldValue) -> Result<()> {
36        match val {
37            FieldValue::Float(v) if (*v < self.min_val) => Err(anyhow!(format!(
38                "value {} is less then {} ({})",
39                v, self.min_val, "Minimum"
40            ))),
41            _ => Ok(()),
42        }
43    }
44}
45
46#[cfg(test)]
47mod tests {
48    use crate::core::constraint::number::minimum::Minimum;
49    use crate::core::constraint::Constraint;
50    use crate::core::value::FieldValue;
51
52    #[test]
53    fn test_minimum_i64() {
54        let constraint = Minimum { min_val: 10i64 };
55
56        let value = FieldValue::Integer(11);
57        assert!(constraint.validate(&value).is_ok());
58
59        let value = FieldValue::Integer(10);
60        assert!(constraint.validate(&value).is_ok());
61
62        let value = FieldValue::Integer(3);
63        assert!(constraint.validate(&value).is_err());
64    }
65
66    #[test]
67    fn test_minimum_u64() {
68        let constraint = Minimum { min_val: 10u64 };
69
70        let value = FieldValue::UInteger(11u64);
71        assert!(constraint.validate(&value).is_ok());
72
73        let value = FieldValue::UInteger(10u64);
74        assert!(constraint.validate(&value).is_ok());
75
76        let value = FieldValue::UInteger(3u64);
77        assert!(constraint.validate(&value).is_err());
78    }
79
80    #[test]
81    fn test_minimum_f64() {
82        let constraint = Minimum { min_val: 10.0 };
83
84        let value = FieldValue::Float(11.0);
85        assert!(constraint.validate(&value).is_ok());
86
87        let value = FieldValue::Float(10.0);
88        assert!(constraint.validate(&value).is_ok());
89
90        let value = FieldValue::Float(3.0);
91        assert!(constraint.validate(&value).is_err());
92    }
93}