apimock-routing 5.1.1

Routing model for apimock: rule sets, request matching, and read-only views for GUI tooling.
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use console::style;
use http_method::HttpMethod;
use serde::Deserialize;

mod body;
mod headers;
pub mod http_method;
pub mod rule_op;
pub mod url_path;
mod util;

use crate::parsed_request::ParsedRequest;
use body::Body;
use headers::Headers;
use url_path::{UrlPath, UrlPathConfig};
use util::fmt_condition_connector;

#[derive(Clone, Deserialize, Debug)]
pub struct Request {
    #[serde(rename = "url_path")]
    pub url_path_config: Option<UrlPathConfig>,
    #[serde(skip)]
    pub url_path: Option<UrlPath>,
    #[serde(rename = "method")]
    pub http_method: Option<HttpMethod>,
    pub headers: Option<Headers>,
    pub body: Option<Body>,
}

impl Request {
    /// match with condition
    pub fn is_match(
        &self,
        parsed_request: &ParsedRequest,
        rule_idx: usize,
        rule_set_idx: usize,
    ) -> bool {
        let url_path_is_match = self.url_path.is_none()
            || self
                .url_path
                .as_ref()
                .unwrap()
                .is_match(parsed_request.url_path.as_str());

        let http_method_is_match = self.http_method.is_none()
            || self
                .http_method
                .as_ref()
                .unwrap()
                .is_match(&parsed_request.component_parts.method);

        let headers_is_match = self.headers.is_none()
            || self.headers.as_ref().unwrap().is_match(
                &parsed_request.component_parts.headers,
                rule_idx,
                rule_set_idx,
            );

        let body_is_match =
            self.body.is_none() || self.body.as_ref().unwrap().is_match(&parsed_request);

        url_path_is_match && http_method_is_match && headers_is_match && body_is_match
    }

    /// validate
    pub fn validate(&self, rule_idx: usize, rule_set_idx: usize) -> bool {
        if self.url_path.is_none()
            && self.http_method.is_none()
            && self.headers.is_none()
            && self.body.is_none()
        {
            log::error!(
                "{} in when.request at least either of: url_path, method, headers or body (rule #{} in rule set #{})",
                style("required").red(),
                rule_idx + 1,
                rule_set_idx + 1
            );
            return false;
        }

        let url_path_validate = match self.url_path.as_ref() {
            Some(url_path) => url_path.validate(),
            None => true,
        };

        let http_method_validate = true;

        let headers_validate = match self.headers.as_ref() {
            Some(headers) => {
                let ret = headers.validate();
                if !ret {
                    log::error!(
                        "something wrong in headers (rule #{} in rule set #{})",
                        rule_idx + 1,
                        rule_set_idx + 1
                    )
                }
                ret
            }
            None => true,
        };

        let body_validate = match self.body.as_ref() {
            Some(body) => {
                let ret = body.validate();
                if !ret {
                    log::error!(
                        "something wrong in body (rule #{} in rule set #{})",
                        rule_idx + 1,
                        rule_set_idx + 1
                    )
                }
                ret
            }
            None => true,
        };

        url_path_validate && http_method_validate && headers_validate && body_validate
    }
}

impl std::fmt::Display for Request {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut s: Vec<String> = vec![];

        if let Some(x) = self.url_path_config.as_ref() {
            s.push(format!("{}", x));
        }
        if let Some(x) = self.http_method.as_ref() {
            s.push(format!("{}", x));
        }
        if let Some(x) = self.headers.as_ref() {
            s.push(format!("{}", x));
        }
        if let Some(x) = self.body.as_ref() {
            s.push(format!("{}", x));
        }

        let _ = write!(f, "{} ", s.join(fmt_condition_connector().as_str()));
        Ok(())
    }
}