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
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

//! The `http::status` DSL provides built-in functions to perform declarative
//! assertions against the status of an http response.
use crate::{
    assertion::{
        traits::{Equality, RangeInclusive},
        Assertion,
    },
    dsl::{is_between, Expression, Predicate, Range},
    grillon::LogSettings,
    StatusCode,
};

/// A short-hand function to test if the status code
/// of the response is in the range of 2xx codes.
pub fn is_success() -> Expression<Range<u16>> {
    is_between(200, 299)
}

/// A short-hand function to test if the status code
/// of the response is in the range of 4xx codes.
pub fn is_client_error() -> Expression<Range<u16>> {
    is_between(400, 499)
}

/// A short-hand function to test if the status code
/// of the response is in the range of 5xx codes.
pub fn is_server_error() -> Expression<Range<u16>> {
    is_between(500, 599)
}

/// Http status DSL to assert the status code of a response.
///
/// ```rust
/// use grillon::{Result, Grillon, StatusCode};
/// use grillon::dsl::{is, is_between, is_not, http::is_success};
///
/// #[tokio::test]
/// async fn check_status() -> Result<()> {
///    Grillon::new("https://jsonplaceholder.typicode.com")?
///        .get("users/1")
///        .assert()
///        .await
///        .status(is(200))
///        .status(is(StatusCode::OK))
///        .status(is_not(500))
///        .status(is_not(StatusCode::INTERNAL_SERVER_ERROR))
///        .status(is_success())
///        .status(is_between(200, 204))
///        .status(is_between(StatusCode::OK, StatusCode::NO_CONTENT));
///
///    Ok(())
/// }
pub trait StatusCodeDsl<T> {
    /// Evaluates the status assertion to run depending on the [`Predicate`].
    /// The test results will be produced on the given output configured via the
    /// [`LogSettings`].
    fn eval(&self, actual: T, predicate: Predicate, log_settings: &LogSettings) -> Assertion<u16>;
}

impl StatusCodeDsl<StatusCode> for StatusCode {
    fn eval(
        &self,
        actual: StatusCode,
        predicate: Predicate,
        log_settings: &LogSettings,
    ) -> Assertion<u16> {
        match predicate {
            Predicate::Is => self.is(actual).assert(log_settings),
            Predicate::IsNot => self.is_not(actual).assert(log_settings),
            _ => unimplemented!("Invalid predicate for the status code DSL: {predicate}"),
        }
    }
}

impl StatusCodeDsl<StatusCode> for u16 {
    fn eval(
        &self,
        actual: StatusCode,
        predicate: Predicate,
        log_settings: &LogSettings,
    ) -> Assertion<u16> {
        match predicate {
            Predicate::Is => self.is(actual).assert(log_settings),
            Predicate::IsNot => self.is_not(actual).assert(log_settings),
            _ => unimplemented!("Invalid predicate for the status code DSL: {predicate}"),
        }
    }
}

impl StatusCodeDsl<StatusCode> for Range<StatusCode> {
    fn eval(
        &self,
        actual: StatusCode,
        predicate: Predicate,
        log_settings: &LogSettings,
    ) -> Assertion<u16> {
        match predicate {
            Predicate::Between => self.is_between(actual).assert(log_settings),
            _ => unimplemented!("Invalid predicate for the status code DSL: {predicate}"),
        }
    }
}

impl StatusCodeDsl<StatusCode> for Range<u16> {
    fn eval(
        &self,
        actual: StatusCode,
        predicate: Predicate,
        log_settings: &LogSettings,
    ) -> Assertion<u16> {
        match predicate {
            Predicate::Between => self.is_between(actual).assert(log_settings),
            _ => unimplemented!("Invalid predicate for the status code DSL: {predicate}"),
        }
    }
}

/// Http status DSL to assert the status code equality of a response.
pub trait StatusCodeDslEquality<T>: StatusCodeDsl<T> {
    /// Builds an assertion comparing the equality between two status codes.
    fn is(&self, actual: T) -> Assertion<u16>;
    /// Builds an assertion comparing the non equality between two status codes.
    fn is_not(&self, actual: T) -> Assertion<u16>;
}

impl StatusCodeDslEquality<StatusCode> for StatusCode {
    fn is(&self, actual: StatusCode) -> Assertion<u16> {
        actual.is_eq(self)
    }

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

impl StatusCodeDslEquality<StatusCode> for u16 {
    fn is(&self, actual: StatusCode) -> Assertion<u16> {
        actual.is_eq(self)
    }

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

/// Http status DSL to assert the status code of a response is in
/// the given inclusive range.
pub trait StatusCodeDslBetween<T>: StatusCodeDsl<T> {
    /// Builds an assertion to check if a status code is within an inclusive
    /// range.
    fn is_between(&self, actual: T) -> Assertion<u16>;
}

impl StatusCodeDslBetween<StatusCode> for Range<StatusCode> {
    fn is_between(&self, actual: StatusCode) -> Assertion<u16> {
        actual.in_range(&self.left, &self.right)
    }
}

impl StatusCodeDslBetween<StatusCode> for Range<u16> {
    fn is_between(&self, actual: StatusCode) -> Assertion<u16> {
        actual.in_range(&self.left, &self.right)
    }
}