1 package jsonpath
2
3 import (
4 "bytes"
5 "encoding/json"
6 "io"
7 "testing"
8 )
9
10 func TestTokensAndPaths(t *testing.T) {
11 j := []byte(`
12 {
13 "foo": 1,
14 "bar": 2,
15 "test": "Hello, world!",
16 "baz": 123.1,
17 "array": [
18 {"foo": 1},
19 {"bar": 2},
20 {"baz": 3}
21 ],
22 "subobj": {
23 "foo": 1,
24 "subarray": [1,2,3],
25 "subsubobj": {
26 "bar": 2,
27 "baz": 3,
28 "array": ["hello", "world"]
29 }
30 },
31 "bool": true,
32 "a": [[0],[[1]]]
33 }`)
34
35 expPaths := []JsonPath{
36 {""},
37 {"foo"}, {"foo"},
38 {"bar"}, {"bar"},
39 {"test"}, {"test"},
40 {"baz"}, {"baz"},
41 {"array"}, {"array", -1},
42 {"array", 0, ""}, {"array", 0, "foo"}, {"array", 0, "foo"}, {"array", 0},
43 {"array", 1, ""}, {"array", 1, "bar"}, {"array", 1, "bar"}, {"array", 1},
44 {"array", 2, ""}, {"array", 2, "baz"}, {"array", 2, "baz"}, {"array", 2},
45 {"array"},
46 {"subobj"},
47 {"subobj", ""},
48 {"subobj", "foo"}, {"subobj", "foo"},
49 {"subobj", "subarray"}, {"subobj", "subarray", -1},
50 {"subobj", "subarray", 0}, {"subobj", "subarray", 1}, {"subobj", "subarray", 2},
51 {"subobj", "subarray"},
52 {"subobj", "subsubobj"}, {"subobj", "subsubobj", ""},
53 {"subobj", "subsubobj", "bar"}, {"subobj", "subsubobj", "bar"},
54 {"subobj", "subsubobj", "baz"}, {"subobj", "subsubobj", "baz"},
55 {"subobj", "subsubobj", "array"}, {"subobj", "subsubobj", "array", -1},
56 {"subobj", "subsubobj", "array", 0}, {"subobj", "subsubobj", "array", 1},
57 {"subobj", "subsubobj", "array"},
58 {"subobj", "subsubobj"}, {"subobj"},
59 {"bool"}, {"bool"},
60 {"a"}, {"a", -1}, {"a", 0, -1}, {"a", 0, 0}, {"a", 0}, {"a", 1, -1},
61 {"a", 1, 0, -1}, {"a", 1, 0, 0}, {"a", 1, 0}, {"a", 1}, {"a"},
62 {},
63 }
64
65 expTokens := []json.Token{
66 json.Delim('{'),
67 KeyString("foo"), float64(1),
68 KeyString("bar"), float64(2),
69 KeyString("test"), "Hello, world!",
70 KeyString("baz"), float64(123.1),
71 KeyString("array"), json.Delim('['),
72 json.Delim('{'), KeyString("foo"), float64(1), json.Delim('}'),
73 json.Delim('{'), KeyString("bar"), float64(2), json.Delim('}'),
74 json.Delim('{'), KeyString("baz"), float64(3), json.Delim('}'),
75 json.Delim(']'),
76 KeyString("subobj"),
77 json.Delim('{'),
78 KeyString("foo"), float64(1),
79 KeyString("subarray"), json.Delim('['),
80 float64(1), float64(2), float64(3),
81 json.Delim(']'),
82 KeyString("subsubobj"), json.Delim('{'),
83 KeyString("bar"), float64(2),
84 KeyString("baz"), float64(3),
85 KeyString("array"), json.Delim('['),
86 "hello", "world",
87 json.Delim(']'),
88 json.Delim('}'), json.Delim('}'),
89 KeyString("bool"), true,
90 KeyString("a"),
91 json.Delim('['), json.Delim('['), float64(0), json.Delim(']'),
92 json.Delim('['), json.Delim('['), float64(1), json.Delim(']'), json.Delim(']'),
93 json.Delim(']'),
94 json.Delim('}'),
95 }
96 outTokens := []json.Token{}
97 outPaths := []JsonPath{}
98
99 d := NewDecoder(bytes.NewBuffer(j))
100
101 for {
102 st, err := d.Token()
103 if err == io.EOF {
104 break
105 } else if err != nil {
106 t.Error(err)
107 break
108 }
109 outTokens = append(outTokens, st)
110 outPaths = append(outPaths, d.Path())
111 }
112
113
114 if len(outTokens) != len(expTokens) {
115 t.Errorf("Out has %v elements, expected %v", len(outTokens), len(expTokens))
116 }
117 for i, v := range expTokens {
118 if v != outTokens[i] {
119 t.Errorf("@%v exp: %T:%v but was: %T:%v", i, v, v, outTokens[i], outTokens[i])
120 }
121 }
122
123
124 if len(outPaths) != len(expPaths) {
125 t.Errorf("Outpaths has %v elements, expected %v", len(outPaths), len(expPaths))
126 }
127 for i, v := range expPaths {
128 if !v.Equal(outPaths[i]) {
129 t.Errorf("@%v exp: %T:%v but was: %T:%v", i, v, v, outPaths[i], outPaths[i])
130 }
131 }
132 }
133
View as plain text