json-predicate 0.1.16

JSON Predicate lib based on draft-snell-json-07
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

// Test adapted from https://github.com/MalcolmDwyer/json-predicate/blob/master/test/test.js

use json_predicate::builder::LessBuilder;
use json_predicate::context::PredicateContext;
use json_predicate::json_path::JSONPath;
use json_predicate::{FirstOrder, Predicate, PredicateImpl};

mod utils;
use serde::Deserialize;
use utils::ENTRY;

#[test]
pub fn test_base_predicate_snapshot() {
    let predicate: Predicate = FirstOrder::from(
        LessBuilder::default()
            .path(JSONPath::new("/stringABC").unwrap())
            .value(12)
            .build()
            .unwrap(),
    )
    .into();

    insta::assert_json_snapshot!(predicate);
}

#[test]
pub fn returns_err_for_non_numeric_comparaisons() {
    let predicate = Predicate::deserialize(serde_json::json!({
        "op": "less",
        "path": "/stringABC",
        "value": "XYZ",
    }));

    assert!(predicate.is_err());
    insta::assert_debug_snapshot!(predicate.unwrap_err(), @r###"Error("data did not match any variant of untagged enum Predicate", line: 0, column: 0)"###);

    let predicate = Predicate::deserialize(serde_json::json!({
        "op": "less",
        "path": "/objA/stringXYZ",
        "value": "ABC",
    }));

    assert!(predicate.is_err());
    insta::assert_debug_snapshot!(predicate.unwrap_err(), @r###"Error("data did not match any variant of untagged enum Predicate", line: 0, column: 0)"###);

    let predicate = Predicate::deserialize(serde_json::json!({
        "op": "less",
        "path": "/objA/stringXYZ",
        "value": ["a", "b"],
    }));

    assert!(predicate.is_err());
    insta::assert_debug_snapshot!(predicate.unwrap_err(), @r###"Error("data did not match any variant of untagged enum Predicate", line: 0, column: 0)"###);

    let predicate = Predicate::deserialize(serde_json::json!({
        "op": "less",
        "path": "/objA/stringXYZ",
        "value": {"a": "foo", "b": "bar"},
    }));

    assert!(predicate.is_err());
    insta::assert_debug_snapshot!(predicate.unwrap_err(), @r###"Error("data did not match any variant of untagged enum Predicate", line: 0, column: 0)"###);
}

#[test]
pub fn returns_true_for_greater_predicate_value() {
    let predicate: Predicate = FirstOrder::from(
        LessBuilder::default()
            .path(JSONPath::new("/objA/objB/num3").unwrap())
            .value(4)
            .build()
            .unwrap(),
    )
    .into();

    let result = predicate.evaluate(&ENTRY, PredicateContext::default());
    assert!(result.is_ok());
    assert!(result.unwrap());
}

#[test]
pub fn returns_false_for_lesser_predicate_value() {
    let predicate: Predicate = FirstOrder::from(
        LessBuilder::default()
            .path(JSONPath::new("/objA/objB/num3").unwrap())
            .value(2)
            .build()
            .unwrap(),
    )
    .into();

    let result = predicate.evaluate(&ENTRY, PredicateContext::default());
    assert!(result.is_ok());
    assert!(!result.unwrap());
}

#[test]
pub fn returns_false_for_equal_numeric_value() {
    let predicate: Predicate = FirstOrder::from(
        LessBuilder::default()
            .path(JSONPath::new("/objA/objB/num3").unwrap())
            .value(3)
            .build()
            .unwrap(),
    )
    .into();

    let result = predicate.evaluate(&ENTRY, PredicateContext::default());
    assert!(result.is_ok());
    assert!(!result.unwrap());
}

#[test]
pub fn returns_err_for_undefined_value() {
    let predicate: Predicate = FirstOrder::from(
        LessBuilder::default()
            .path(JSONPath::new("/objZZZ/objZZZZZZZZ").unwrap())
            .value(3)
            .build()
            .unwrap(),
    )
    .into();

    let result = predicate.evaluate(&ENTRY, PredicateContext::default());
    assert!(result.is_err());
}