rustapi-testing 0.1.453

Testing utilities for RustAPI applications. Provides checking helpers, test servers, and fluid assertions.
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

use super::matcher::RequestMatcher;
use bytes::Bytes;
use http::{HeaderMap, StatusCode};

/// An expectation for a request
#[derive(Debug, Clone)]
pub struct Expectation {
    pub(crate) matcher: RequestMatcher,
    pub(crate) response: MockResponse,
    pub(crate) times: Times,
    pub(crate) call_count: usize,
}

impl Expectation {
    /// Create a new expectation
    pub fn new(matcher: RequestMatcher) -> Self {
        Self {
            matcher,
            response: MockResponse::default(),
            times: Times::Once,
            call_count: 0,
        }
    }

    /// Set the response to match
    pub fn respond_with(mut self, response: MockResponse) -> Self {
        self.response = response;
        self
    }

    /// Expect the request to be called exactly once
    pub fn once(mut self) -> Self {
        self.times = Times::Once;
        self
    }

    /// Expect the request to be called exactly n times
    pub fn times(mut self, n: usize) -> Self {
        self.times = Times::Exactly(n);
        self
    }

    /// Expect the request to be called at least once
    pub fn at_least_once(mut self) -> Self {
        self.times = Times::AtLeast(1);
        self
    }

    /// Expect the request to never be called
    pub fn never(mut self) -> Self {
        self.times = Times::Exactly(0);
        self
    }
}

/// Define how many times an expectation should be matched
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Times {
    Once,
    Exactly(usize),
    AtLeast(usize),
    AtMost(usize),
    Any,
}

/// A mocked response
#[derive(Debug, Clone)]
pub struct MockResponse {
    pub(crate) status: StatusCode,
    pub(crate) headers: HeaderMap,
    pub(crate) body: Bytes,
}

impl Default for MockResponse {
    fn default() -> Self {
        Self {
            status: StatusCode::OK,
            headers: HeaderMap::new(),
            body: Bytes::new(),
        }
    }
}

impl MockResponse {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn status(mut self, status: StatusCode) -> Self {
        self.status = status;
        self
    }

    pub fn header(mut self, key: &str, value: &str) -> Self {
        self.headers.insert(
            http::header::HeaderName::from_bytes(key.as_bytes()).unwrap(),
            http::header::HeaderValue::from_str(value).unwrap(),
        );
        self
    }

    pub fn body(mut self, body: impl Into<Bytes>) -> Self {
        self.body = body.into();
        self
    }

    pub fn json(mut self, body: impl serde::Serialize) -> Self {
        self.headers.insert(
            http::header::CONTENT_TYPE,
            http::header::HeaderValue::from_static("application/json"),
        );
        self.body = serde_json::to_vec(&body).unwrap().into();
        self
    }
}