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
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

use crate::{
    assertion::{
        traits::{Container, Equality},
        types::Headers,
        Assertion,
    },
    dsl::expression::Predicate,
    header::{HeaderMap, HeaderName, HeaderValue},
    LogSettings,
};

// TODO: see to use the low-level types
type HeadersVec = Vec<(HeaderName, HeaderValue)>;
type HeadersStrVec = Vec<(&'static str, &'static str)>;

/// Http header DSL to assert a specific header of the response.
pub trait HeadersDsl<T> {
    /// Asserts the headers are strictly equal to the provided ones.
    fn is(&self, actual: T) -> Assertion<Headers>;
    /// Asserts the headers are strictly not equal to the provided ones.
    fn is_not(&self, actual: T) -> Assertion<Headers>;
    /// Asserts the headers contain a specific header by key - value.
    fn contains(&self, actual: T) -> Assertion<Headers>;
    /// Asserts the headers does not contain a specific header by key - value.
    fn does_not_contain(&self, actual: T) -> Assertion<Headers>;
    /// Evaluates the headers assertion to run based on the [`Predicate`].
    fn eval(
        &self,
        actual: T,
        predicate: Predicate,
        log_settings: &LogSettings,
    ) -> Assertion<Headers> {
        match predicate {
            Predicate::Is => self.is(actual).assert(log_settings),
            Predicate::IsNot => self.is_not(actual).assert(log_settings),
            Predicate::Contains => self.contains(actual).assert(log_settings),
            Predicate::DoesNotContain => self.does_not_contain(actual).assert(log_settings),
            _ => unimplemented!("Invalid predicate for the headers DSL: {predicate}"),
        }
    }
}

impl HeadersDsl<HeaderMap> for HeaderMap {
    fn is(&self, actual: HeaderMap) -> Assertion<Headers> {
        actual.is_eq(self)
    }

    fn is_not(&self, actual: HeaderMap) -> Assertion<Headers> {
        actual.is_ne(self)
    }

    fn contains(&self, actual: HeaderMap) -> Assertion<Headers> {
        actual.has(self)
    }

    fn does_not_contain(&self, actual: HeaderMap) -> Assertion<Headers> {
        actual.has_not(self)
    }
}

impl HeadersDsl<HeaderMap> for HeadersVec {
    fn is(&self, actual: HeaderMap) -> Assertion<Headers> {
        actual.is_eq(self)
    }

    fn is_not(&self, actual: HeaderMap) -> Assertion<Headers> {
        actual.is_ne(self)
    }

    fn contains(&self, actual: HeaderMap) -> Assertion<Headers> {
        actual.has(self)
    }

    fn does_not_contain(&self, actual: HeaderMap) -> Assertion<Headers> {
        actual.has_not(self)
    }
}

impl HeadersDsl<HeaderMap> for HeadersStrVec {
    fn is(&self, actual: HeaderMap) -> Assertion<Headers> {
        actual.is_eq(self)
    }

    fn is_not(&self, actual: HeaderMap) -> Assertion<Headers> {
        actual.is_ne(self)
    }

    fn contains(&self, actual: HeaderMap) -> Assertion<Headers> {
        actual.has(self)
    }

    fn does_not_contain(&self, actual: HeaderMap) -> Assertion<Headers> {
        actual.has_not(self)
    }
}