grillon 0.6.0

Grillon offers an elegant and natural way to approach API testing in Rust.
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

use crate::{
    assertion::{traits::LessThan, Assertion, Hand},
    dsl::{Part, Predicate},
};

impl LessThan<u64> for u64 {
    type Assertion = Assertion<u64>;

    fn less_than(&self, other: &u64) -> Self::Assertion {
        let result = self < other;

        Assertion {
            part: Part::ResponseTime,
            predicate: Predicate::LessThan,
            left: Hand::Left(*self),
            right: Hand::Right(*other),
            result: result.into(),
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::assertion::traits::LessThan;

    #[test]
    fn it_should_be_less_than() {
        let assertion = 20_u64.less_than(&30);
        assert!(assertion.passed(), "{}", assertion.log());
    }

    #[test]
    fn it_should_not_be_less_than() {
        let assertion = u64::MAX.less_than(&30);
        assert!(assertion.failed(), "{}", assertion.log());
    }

    mod serialization {
        use super::*;
        use serde_json::json;

        #[test]
        fn it_serializes_time_less_than() {
            let expected_json = json!({
                "part": "response time",
                "predicate": "should be less than",
                "left": 200_u64,
                "right": 300_u64,
                "result": "passed"
            });

            let assertion = 200.less_than(&300);

            assert_eq!(
                json!(assertion),
                expected_json,
                "Serialized assertion is not equals to the expected json",
            );
        }
    }
}