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::expect_op::expect_op;
use crate::expect_op::ExpectOp;
use crate::internals::objects::StringObject;
use crate::expect_op::Context;
use crate::ExpectOpError;
use crate::ExpectOpResult;
use crate::JsonType;

#[expect_op(internal)]
#[derive(Clone, Debug, PartialEq)]
pub struct StringContainsNot {
    content: String,
}

impl StringContainsNot {
    pub(crate) fn new(content: String) -> Self {
        Self { content }
    }
}

impl ExpectOp for StringContainsNot {
    fn on_string(&self, context: &mut Context<'_>, received: &str) -> ExpectOpResult<()> {
        if received.contains(&self.content) {
            return Err(ExpectOpError::ContainsFound {
                context: context.to_static(),
                json_type: JsonType::String,
                expected: StringObject::from(self.content.clone()).into(),
                received: StringObject::from(received.to_owned()).into(),
            });
        }

        Ok(())
    }

    fn supported_types(&self) -> &'static [JsonType] {
        &[JsonType::String]
    }
}

#[cfg(test)]
mod test_string_contains_not {
    use crate::expect;
    use crate::expect_json_eq;
    use pretty_assertions::assert_eq;
    use serde_json::json;

    #[test]
    fn it_should_error_for_identical_strings() {
        let left = json!("1, 2, 3");
        let right = json!(expect.not.contains("1, 2, 3"));

        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
        assert_eq!(
            output,
            r#"Json string at root contains value was expecting to not be there:
    expected string to not contain "1, 2, 3", but it was found.
    received "1, 2, 3""#
        );
    }

    #[test]
    fn it_should_error_for_partial_matches_in_middle() {
        let left = json!("0, 1, 2, 3, 4");
        let right = json!(expect.not.contains("1, 2, 3"));

        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
        assert_eq!(
            output,
            r#"Json string at root contains value was expecting to not be there:
    expected string to not contain "1, 2, 3", but it was found.
    received "0, 1, 2, 3, 4""#
        );
    }

    #[test]
    fn it_should_be_ok_for_empty_contains() {
        let left = json!("0, 1, 2, 3, 4, 5");
        let right = json!(expect.not.contains(""));

        let output = expect_json_eq(&left, &right).unwrap_err().to_string();
        assert_eq!(
            output,
            r#"Json string at root contains value was expecting to not be there:
    expected string to not contain "", but it was found.
    received "0, 1, 2, 3, 4, 5""#
        );
    }

    #[test]
    fn it_should_be_ok_for_totall_different_values() {
        let left = json!("1, 2, 3");
        let right = json!(expect.not.contains("a, b, c"));

        let output = expect_json_eq(&left, &right);
        assert!(output.is_ok());
    }
}