tarn 0.6.2

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

pub mod body;
pub mod duration;
pub mod headers;
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());
    }
}