httpmock 0.9.0

HTTP mocking library 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
125
126

//! Server-side state for forwarding and proxy rules.

use std::collections::BTreeMap;

use crate::{
    common::data::{ActiveForwardingRule, ActiveProxyRule, ForwardingRuleConfig, ProxyRuleConfig},
    prelude::HttpMockRequest,
    server::state::{Error, HttpMockStateManager, request_matches},
};

#[derive(Default)]
pub(super) struct State {
    next_forwarding_rule_id: usize,
    next_proxy_rule_id: usize,
    forwarding_rules: BTreeMap<usize, ActiveForwardingRule>,
    proxy_rules: BTreeMap<usize, ActiveProxyRule>,
}

impl HttpMockStateManager {
    pub(crate) fn create_forwarding_rule(&self, config: ForwardingRuleConfig) -> ActiveForwardingRule {
        let mut state = self.state.lock().unwrap();

        let rule = ActiveForwardingRule {
            id: state.proxy.next_forwarding_rule_id,
            config,
        };

        state.proxy.forwarding_rules.insert(rule.id, rule.clone());

        state.proxy.next_forwarding_rule_id += 1;

        rule
    }

    pub(crate) fn delete_forwarding_rule(&self, id: usize) -> Option<ActiveForwardingRule> {
        let mut state = self.state.lock().unwrap();

        let result = state.proxy.forwarding_rules.remove(&id);

        if result.is_some() {
            tracing::debug!("Deleting forwarding rule with id={}", id);
        } else {
            tracing::warn!(
                "Could not delete forwarding rule with id={} (no forwarding rule with that id found)",
                id
            );
        }

        result
    }

    pub(crate) fn delete_all_forwarding_rules(&self) {
        let mut state = self.state.lock().unwrap();
        state.proxy.forwarding_rules.clear();

        tracing::debug!("Deleted all forwarding rules");
    }

    pub(crate) fn create_proxy_rule(&self, config: ProxyRuleConfig) -> ActiveProxyRule {
        let mut state = self.state.lock().unwrap();

        let rule = ActiveProxyRule {
            id: state.proxy.next_proxy_rule_id,
            config,
        };

        state.proxy.proxy_rules.insert(rule.id, rule.clone());

        state.proxy.next_proxy_rule_id += 1;

        rule
    }

    pub(crate) fn delete_proxy_rule(&self, id: usize) -> Option<ActiveProxyRule> {
        let mut state = self.state.lock().unwrap();

        let result = state.proxy.proxy_rules.remove(&id);

        if result.is_some() {
            tracing::debug!("Deleting proxy rule with id={}", id);
        } else {
            tracing::warn!(
                "Could not delete proxy rule with id={} (no proxy rule with that id found)",
                id
            );
        }

        result
    }

    pub(crate) fn delete_all_proxy_rules(&self) {
        let mut state = self.state.lock().unwrap();
        state.proxy.proxy_rules.clear();

        tracing::debug!("Deleted all proxy rules");
    }

    pub(crate) fn find_forward_rule<'a>(
        &'a self,
        req: &'a HttpMockRequest,
    ) -> Result<Option<ActiveForwardingRule>, Error> {
        let state = self.state.lock().unwrap();

        let result = state
            .proxy
            .forwarding_rules
            .values()
            .find(|&rule| request_matches(&state.matchers, req, &rule.config.request_requirements))
            .cloned();

        Ok(result)
    }

    pub(crate) fn find_proxy_rule<'a>(&'a self, req: &'a HttpMockRequest) -> Result<Option<ActiveProxyRule>, Error> {
        let state = self.state.lock().unwrap();

        let result = state
            .proxy
            .proxy_rules
            .values()
            .find(|&rule| request_matches(&state.matchers, req, &rule.config.request_requirements))
            .cloned();

        Ok(result)
    }
}