tarn 0.11.6

CLI-first API testing tool
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

pub mod body;
pub mod duration;
pub mod headers;
pub mod hints;
pub mod redirect;
pub mod status;
pub mod types;

use types::AssertionResult;

use crate::http::HttpResponse;
use crate::model::Assertion;

/// Run all assertions for a step and return results.
pub fn run_assertions(assertion: &Assertion, response: &HttpResponse) -> Vec<AssertionResult> {
    let mut results = Vec::new();

    // Status assertion
    if let Some(ref expected_status) = assertion.status {
        results.push(status::assert_status(expected_status, response.status));
    }

    // Duration assertion
    if let Some(ref duration_spec) = assertion.duration {
        results.push(duration::assert_duration(
            duration_spec,
            response.duration_ms,
        ));
    }

    // Redirect assertions
    if let Some(ref expected_redirect) = assertion.redirect {
        results.extend(redirect::assert_redirect(
            expected_redirect,
            &response.url,
            response.redirect_count,
        ));
    }

    // Header assertions
    if let Some(ref expected_headers) = assertion.headers {
        results.extend(headers::assert_headers(expected_headers, &response.headers));
    }

    // Body assertions
    if let Some(ref body_assertions) = assertion.body {
        results.extend(body::assert_body(
            &response.body,
            &response.body_bytes,
            body_assertions,
        ));
    }

    results
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::http::{HttpResponse, ResponseTimings};
    use crate::model::StatusAssertion;
    use std::collections::HashMap;

    fn mock_response(status: u16) -> HttpResponse {
        HttpResponse {
            status,
            url: String::new(),
            redirect_count: 0,
            headers: HashMap::new(),
            raw_headers: vec![],
            body_bytes: vec![],
            body: serde_json::Value::Null,
            duration_ms: 100,
            timings: ResponseTimings {
                total_ms: 100,
                ttfb_ms: 50,
                body_read_ms: 50,
                connect_ms: None,
                tls_ms: None,
            },
        }
    }

    #[test]
    fn run_assertions_status_only() {
        let assertion = Assertion {
            status: Some(StatusAssertion::Exact(200)),
            duration: None,
            redirect: None,
            headers: None,
            body: None,
        };
        let response = mock_response(200);
        let results = run_assertions(&assertion, &response);
        assert_eq!(results.len(), 1);
        assert!(results[0].passed);
    }

    #[test]
    fn run_assertions_status_fails() {
        let assertion = Assertion {
            status: Some(StatusAssertion::Exact(200)),
            duration: None,
            redirect: None,
            headers: None,
            body: None,
        };
        let response = mock_response(404);
        let results = run_assertions(&assertion, &response);
        assert_eq!(results.len(), 1);
        assert!(!results[0].passed);
    }

    #[test]
    fn run_assertions_no_assertions() {
        let assertion = Assertion {
            status: None,
            duration: None,
            redirect: None,
            headers: None,
            body: None,
        };
        let response = mock_response(200);
        let results = run_assertions(&assertion, &response);
        assert!(results.is_empty());
    }
}