expect-json 1.10.1

For comparisons on JSON data
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

use crate::ExpectJsonError;
use crate::ExpectJsonResult;
use crate::JsonType;
use crate::expect_core::Context;
use crate::internals::JsonObject;
use crate::internals::objects::ObjectObject;

pub fn json_value_eq_object<'a>(
    context: &mut Context<'a>,
    received: &'a JsonObject,
    expected: &'a JsonObject,
) -> ExpectJsonResult<()> {
    if context.is_propagated_contains() {
        return json_value_eq_object_contains(context, received, expected);
    }

    let received_len = received.len();
    let expected_len = expected.len();

    // We have a special error case when there is only one extra field,
    // for prettier error output.
    if received_len == expected_len + 1 {
        let maybe_extra_field = received.keys().find(|key| !expected.contains_key(*key));

        if let Some(extra_field) = maybe_extra_field {
            return Err(ExpectJsonError::ObjectReceivedHasExtraKey {
                context: context.to_static(),
                received_extra_field: extra_field.to_string(),
                received_obj: ObjectObject::from(received.clone()).into(),
                expected_obj: ObjectObject::from(expected.clone()).into(),
            });
        }
    }

    // For when received many extra field over what is expected.
    if received_len > expected_len {
        let extra_fields = received
            .keys()
            .filter(|key| !expected.contains_key(*key))
            .cloned()
            .collect();

        return Err(ExpectJsonError::ObjectReceivedHasExtraKeys {
            context: context.to_static(),
            received_extra_fields: extra_fields,
            received_obj: ObjectObject::from(received.clone()).into(),
            expected_obj: ObjectObject::from(expected.clone()).into(),
        });
    }

    if received.len() != expected.len() {
        return Err(ExpectJsonError::DifferentValues {
            context: context.to_static(),
            json_type: JsonType::Object,
            received: ObjectObject::from(received.clone()).into(),
            expected: ObjectObject::from(expected.clone()).into(),
        });
    }

    for (expected_key, expected_value) in expected.iter() {
        let received_value =
            received
                .get(expected_key)
                .ok_or_else(|| ExpectJsonError::ObjectKeyMissing {
                    context: context.to_static(),
                    expected_key: expected_key.to_string(),
                })?;

        context
            .with_path(expected_key)
            .json_eq(received_value, expected_value)?;
    }

    Ok(())
}

pub fn json_value_eq_object_contains<'a>(
    context: &mut Context<'a>,
    received: &'a JsonObject,
    expected: &'a JsonObject,
) -> ExpectJsonResult<()> {
    for (expected_key, expected_value) in expected {
        let received_value =
            received
                .get(expected_key)
                .ok_or_else(|| ExpectJsonError::ObjectKeyMissing {
                    context: context.to_static(),
                    expected_key: expected_key.to_string(),
                })?;

        context
            .with_path(expected_key)
            .json_eq(received_value, expected_value)?;
    }

    Ok(())
}