mocktail 0.3.2

HTTP & gRPC server mocking for 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

//! Mock set
use crate::{
    mock::Mock,
    mock_builder::{Then, When},
    request::Request,
};

/// A set of mocks.
#[derive(Default, Debug, Clone)]
pub struct MockSet(Vec<Mock>);

impl MockSet {
    /// Creates an empty mockset.
    pub fn new() -> Self {
        Self::default()
    }

    /// Returns the number of mocks.
    pub fn len(&self) -> usize {
        self.0.len()
    }

    /// Returns true if empty.
    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    /// Inserts a mock.
    pub fn insert(&mut self, mock: Mock) {
        if !self.contains(&mock) {
            self.0.push(mock);
            self.0.sort_by_key(|mock| mock.priority());
        }
    }

    // Returns `true` if the mockset contains the mock.
    pub fn contains(&self, mock: &Mock) -> bool {
        self.0.contains(mock)
    }

    /// Builds and inserts a mock with default options.
    pub fn mock<F>(&mut self, f: F)
    where
        F: FnOnce(When, Then),
    {
        let mock = Mock::new(f);
        self.insert(mock);
    }

    /// Builds and inserts a mock with options.
    pub fn mock_with_options<F>(&mut self, priority: u8, limit: Option<usize>, f: F)
    where
        F: FnOnce(When, Then),
    {
        let mut mock = Mock::new(f).with_priority(priority);
        if let Some(limit) = limit {
            mock = mock.with_limit(limit);
        }
        self.insert(mock);
    }

    /// Finds a mock by predicate.
    pub fn find<P>(&self, predicate: P) -> Option<&Mock>
    where
        P: FnMut(&&Mock) -> bool,
    {
        self.0.iter().find(predicate)
    }

    /// Removes a mock by index.
    pub fn remove(&mut self, index: usize) -> Mock {
        self.0.remove(index)
    }

    /// Clears the mockset.
    pub fn clear(&mut self) {
        self.0.clear()
    }

    /// Returns an iterator over the mockset.
    pub fn iter(&self) -> std::slice::Iter<'_, Mock> {
        self.0.iter()
    }

    /// Matches a request to a mock.
    pub fn match_by_request(&self, request: &Request) -> Option<Mock> {
        self.0.iter().find(|&mock| mock.matches(request)).cloned()
    }
}

impl IntoIterator for MockSet {
    type Item = Mock;

    type IntoIter = std::vec::IntoIter<Self::Item>;

    fn into_iter(self) -> Self::IntoIter {
        self.0.into_iter()
    }
}

impl FromIterator<Mock> for MockSet {
    fn from_iter<I: IntoIterator<Item = Mock>>(iter: I) -> Self {
        Self(iter.into_iter().collect())
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_builder() {
        let mut mocks = MockSet::new();
        mocks.mock(|when, then| {
            when.post().path("/hello").text("hello");
            then.text("hello!");
        });
        mocks.mock(|when, then| {
            when.post().path("/hello").text("hey");
            then.text("hello!");
        });
        assert_eq!(mocks.len(), 2);
    }
}