assert_json 0.1.0

json testing made simple
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use crate::{Error, Validator, Value};

/// Match if string match predicate.
pub fn string<F>(predicate: F) -> impl Validator
where
    F: Fn(&String) -> Result<(), String> + 'static,
{
    PrimitiveValidator {
        typename: String::from("string"),
        extract: |val| val.as_str().map(String::from),
        predicate,
    }
}

/// Match if null.
pub fn null() -> impl Validator {
    PrimitiveValidator {
        typename: String::from("null"),
        extract: |val| val.as_null(),
        predicate: |_| Ok(()),
    }
}

/// Match if bool match predicate.
pub fn bool<F>(predicate: F) -> impl Validator
where
    F: Fn(&bool) -> Result<(), String> + 'static,
{
    PrimitiveValidator {
        typename: String::from("bool"),
        extract: |val| val.as_bool(),
        predicate,
    }
}

/// Match if number match predicate.
pub fn i64<F>(predicate: F) -> impl Validator
where
    F: Fn(&i64) -> Result<(), String> + 'static,
{
    PrimitiveValidator {
        typename: String::from("i64"),
        extract: |val| val.as_i64(),
        predicate,
    }
}

/// Match if number match predicate.
pub fn u64<F>(predicate: F) -> impl Validator
where
    F: Fn(&u64) -> Result<(), String> + 'static,
{
    PrimitiveValidator {
        typename: String::from("u64"),
        extract: |val| val.as_u64(),
        predicate,
    }
}

/// Match if number match predicate.
pub fn f64<F>(predicate: F) -> impl Validator
where
    F: Fn(&f64) -> Result<(), String> + 'static,
{
    PrimitiveValidator {
        typename: String::from("f64"),
        extract: |val| val.as_f64(),
        predicate,
    }
}

struct PrimitiveValidator<T, F, G>
where
    F: Fn(&T) -> Result<(), String>,
    G: Fn(&Value) -> Option<T>,
{
    typename: String,
    extract: G,
    predicate: F,
}

impl<T, F, G> Validator for PrimitiveValidator<T, F, G>
where
    F: Fn(&T) -> Result<(), String>,
    G: Fn(&Value) -> Option<T>,
{
    fn validate<'a>(&self, value: &'a Value) -> Result<(), Error<'a>> {
        let val = (self.extract)(value)
            .ok_or_else(|| Error::InvalidType(value, self.typename.clone()))?;

        (self.predicate)(&val).map_err(|msg| Error::InvalidValue(value, msg))
    }
}

#[cfg(test)]
mod tests {
    use crate::{Error, Validator, Value};

    #[test]
    fn string() {
        let validator = super::string(|_| Ok(()));

        assert_eq!(Ok(()), validator.validate(&Value::String("ok".to_string())));
    }

    #[test]
    fn string_invalid_value() {
        let validator = super::string(|_| Err(String::from("error message")));

        assert!(matches!(
            validator.validate(&Value::String("".to_string())),
            Err(Error::InvalidValue(_, _))
        ));
    }

    #[test]
    fn string_invalid_type() {
        let validator = super::string(|_| Ok(()));

        assert!(matches!(
            validator.validate(&Value::Null),
            Err(Error::InvalidType(_, _))
        ));
    }

    #[test]
    fn null() {
        let validator = super::null();

        assert_eq!(Ok(()), validator.validate(&Value::Null));
    }

    #[test]
    fn i64() {
        let validator = super::i64(|_| Ok(()));

        assert_eq!(Ok(()), validator.validate(&serde_json::json!(4)));
    }
}