assert-json-diff 0.1.0

Easily compare two JSON values and get great output
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

# assert-json-diff

This crate includes an assert macro for comparing two JSON values. It is designed to give much
more helpful error messages than the standard [`assert_eq!`]. It basically does a diff of the
two objects and tells you the exact differences. This is useful when asserting that two large
JSON objects are the same.

It uses the [`serde_json::Value`] type to represent JSON.

[`serde_json::Value`]: https://docs.serde.rs/serde_json/value/enum.Value.html
[`assert_eq!`]: https://doc.rust-lang.org/std/macro.assert_eq.html

### Example

```rust
#[macro_use]
extern crate assert_json_diff;
#[macro_use]
extern crate serde_json;

// probably with #[test] attribute
fn some_test() {
    let a = json!({
        "data": {
            "users": [
                {
                    "id": 1,
                    "country": {
                        "name": "Denmark"
                    }
                },
                {
                    "id": 24,
                    "country": {
                        "name": "Denmark"
                    }
                }
            ]
        }
    });

    let b = json!({
        "data": {
            "users": [
                {
                    "id": 1,
                    "country": {
                        "name": "Sweden"
                    }
                },
                {
                    "id": 2,
                    "country": {
                        "name": "Denmark"
                    }
                }
            ]
        }
    });

    assert_json_eq!(actual: a, expected: b)
}
```

This will panic with the error message:

```
json atoms at path ".data.users[0].country.name" are not equal:
    expected:
        "Sweden"
    actual:
        "Denmark"

json atoms at path ".data.users[1].id" are not equal:
    expected:
        2
    actual:
        24
```

### Additional data

It allows extra data in `actual` but not in `expected`. That is so you can verify just a part
of the JSON without having to specify the whole thing. For example this test passes:

```rust
#[macro_use]
extern crate assert_json_diff;
#[macro_use]
extern crate serde_json;

// probably with #[test] attribute
fn some_test() {
    assert_json_eq!(
        actual: json!({
            "a": { "b": 1 },
        }),
        expected: json!({
            "a": {},
        })
    )
}
```

However `expected` cannot contain additional data so this test fails:

```rust
#[macro_use]
extern crate assert_json_diff;
#[macro_use]
extern crate serde_json;

// probably with #[test] attribute
fn some_test() {
    assert_json_eq!(
        actual: json!({
            "a": {},
        }),
        expected: json!({
            "a": { "b": 1 },
        })
    )
}
```

That will print

```
json atom at path ".a.b" is missing from expected
```

### The macro

The `assert_json_eq!` macro can be called with or without typing `actual:` and `expected:`

```rust
#[macro_use]
extern crate assert_json_diff;
#[macro_use]
extern crate serde_json;

// probably with #[test] attribute
fn some_test() {
    assert_json_eq!(
        actual: json!(true),
        expected: json!(true)
    )
}

// probably with #[test] attribute
fn some_other_test() {
    assert_json_eq!(
        json!(true),
        json!(true)
    )
}
```

The version that includes `actual:` and `expected:` is preferred because it makes it very clear
which is which and there [which can contain additional data](#additional-data)

License: MIT