stubr 0.6.2

Wiremock implemented in 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

use itertools::Itertools;
use serde_json::{Map, Value};

use crate::model::response::{
    template::{
        data::{HandlebarsData, RequestData},
        utils::TemplateExt,
        verify::Predictable,
        HandlebarTemplatable,
    },
    ResponseStub,
};
use crate::{StubrError, StubrResult};

use super::{
    super::super::{StdResponse, Verifier},
    JsonBodyTemplatingVerifier,
};

pub struct JsonObjectVerifier<'a> {
    pub actual: &'a Map<String, Value>,
    pub expected: &'a Map<String, Value>,
}

impl JsonObjectVerifier<'_> {
    fn to_bytes(&self, value: &Value) -> Option<Vec<u8>> {
        match value {
            Value::String(s) => Some(s.as_bytes().to_vec()),
            Value::Number(n) => Some(n.to_string().as_bytes().to_vec()),
            Value::Null => Some("null".to_string().as_bytes().to_vec()),
            Value::Bool(b) => Some(b.to_string().as_bytes().to_vec()),
            Value::Array(_) => None,
            Value::Object(_) => None,
        }
    }

    fn cast_to_value(&self, raw: &str) -> Value {
        if let Ok(i) = raw.parse::<i32>() {
            Value::from(i)
        } else if let Ok(b) = raw.parse::<bool>() {
            Value::from(b)
        } else if let Ok(f) = raw.parse::<f64>() {
            Value::from(f)
        } else if raw == "null" {
            Value::Null
        } else {
            Value::from(raw)
        }
    }
}

impl<'a> TryFrom<&'a JsonBodyTemplatingVerifier> for JsonObjectVerifier<'a> {
    type Error = StubrError;

    fn try_from(parent: &'a JsonBodyTemplatingVerifier) -> StubrResult<Self> {
        parent
            .actual
            .as_object()
            .zip(parent.expected.as_object())
            .map(|(actual, expected)| Self { actual, expected })
            .ok_or_else(|| StubrError::QuietError)
    }
}

impl Verifier<'_> for JsonObjectVerifier<'_> {
    fn verify(self, stub: &'_ ResponseStub, name: &'_ str, req: &'_ RequestData, resp: &'_ mut StdResponse) {
        let key_diff = self.expected.keys().filter(|k| !self.actual.keys().contains(k)).collect_vec();
        assert!(
            key_diff.is_empty(),
            "Verification failed for stub '{}'. Expected json fields '{:?}' were absent from response body",
            name,
            self.expected
                .iter()
                .filter(|(k, _)| key_diff.contains(k))
                .map(|(k, v)| (k, v.as_str().unwrap_or_default()))
                .collect_vec()
        );
        let actual = self
            .actual
            .iter()
            .filter(|(k, _)| self.expected.keys().contains(k))
            .sorted_by_key(|(k, _)| k.as_str());
        actual
            .zip(self.expected.iter().sorted_by_key(|(k, _)| k.as_str()))
            .for_each(|((_, va), (ke, ve))| {
                if let Some(expected) = ve.as_str().filter(|v| v.has_template_expressions()) {
                    let response = self.to_bytes(va);
                    let data = HandlebarsData {
                        request: req,
                        response: response.as_deref(),
                        is_verify: true,
                        stub_name: Some(name),
                    };
                    stub.body.register(expected, expected);
                    let render = stub.body.render(expected, &data).unwrap_or_default();
                    if expected.is_predictable() {
                        assert_eq!(
                            va,
                            &self.cast_to_value(&render),
                            "Verification failed for stub '{name}'. Expected json response body for field '{ke}' to be '{render}' but was '{va}'"
                        )
                    }
                } else {
                    JsonBodyTemplatingVerifier {
                        actual: va.clone(),
                        expected: ve.clone(),
                    }
                    .verify(stub, name, req, resp)
                }
            })
    }
}