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 package gojsonpointer
27
28 import (
29 "encoding/json"
30 "testing"
31 )
32
33 const (
34 TEST_DOCUMENT_NB_ELEMENTS = 13
35 TEST_NODE_OBJ_NB_ELEMENTS = 4
36 TEST_DOCUMENT_STRING = `{
37 "foo": ["bar", "baz"],
38 "obj": { "a":1, "b":2, "c":[3,4], "d":[ {"e":9}, {"f":[50,51]} ] },
39 "": 0,
40 "a/b": 1,
41 "c%d": 2,
42 "e^f": 3,
43 "g|h": 4,
44 "i\\j": 5,
45 "k\"l": 6,
46 " ": 7,
47 "m~n": 8,
48 "o~/p": 9,
49 "q/~r": 10
50 }`
51 )
52
53 var testDocumentJson interface{}
54
55 func init() {
56 json.Unmarshal([]byte(TEST_DOCUMENT_STRING), &testDocumentJson)
57 }
58
59 func TestEscaping(t *testing.T) {
60
61 ins := []string{`/`, `/`, `/a~1b`, `/a~1b`, `/c%d`, `/e^f`, `/g|h`, `/i\j`, `/k"l`, `/ `, `/m~0n`, `/o~0~1p`, `/q~1~0r`}
62 outs := []float64{0, 0, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
63
64 for i := range ins {
65
66 p, err := NewJsonPointer(ins[i])
67 if err != nil {
68 t.Errorf("NewJsonPointer(%v) error %v", ins[i], err.Error())
69 }
70 s := p.String()
71 if s != ins[i] {
72 t.Errorf("\"%v\" -> \"%v\"", ins[i], s)
73 }
74
75 result, _, err := p.Get(testDocumentJson)
76 if err != nil {
77 t.Errorf("Get(%v) error %v", ins[i], err.Error())
78 }
79
80 if result != outs[i] {
81 t.Errorf("Get(%v) = %v, expect %v", ins[i], result, outs[i])
82 }
83 }
84
85 }
86
87 func BenchmarkParse(b *testing.B) {
88 for i := 0; i < b.N; i++ {
89 NewJsonPointer(`/definitions/simple/0/next`)
90 }
91 }
92
93 func BenchmarkParseWithEscape(b *testing.B) {
94 for i := 0; i < b.N; i++ {
95 NewJsonPointer(`/definiti~0ons/simple/0/next`)
96 }
97 }
98
99 func BenchmarkString(b *testing.B) {
100 p, _ := NewJsonPointer(`/definitions/simple/0/next`)
101 b.ResetTimer()
102 for i := 0; i < b.N; i++ {
103 p.String()
104 }
105 }
106
107 func BenchmarkStringWithEscape(b *testing.B) {
108 p, _ := NewJsonPointer(`/definiti~0ons/simple/0/next`)
109 b.ResetTimer()
110 for i := 0; i < b.N; i++ {
111 p.String()
112 }
113 }
114
115 func TestFullDocument(t *testing.T) {
116
117 in := ``
118
119 p, err := NewJsonPointer(in)
120 if err != nil {
121 t.Errorf("NewJsonPointer(%v) error %v", in, err.Error())
122 }
123
124 result, _, err := p.Get(testDocumentJson)
125 if err != nil {
126 t.Errorf("Get(%v) error %v", in, err.Error())
127 }
128
129 if len(result.(map[string]interface{})) != TEST_DOCUMENT_NB_ELEMENTS {
130 t.Errorf("Get(%v) = %v, expect full document", in, result)
131 }
132 }
133
134 func TestGetNode(t *testing.T) {
135
136 in := `/obj`
137
138 p, err := NewJsonPointer(in)
139 if err != nil {
140 t.Errorf("NewJsonPointer(%v) error %v", in, err.Error())
141 }
142
143 result, _, err := p.Get(testDocumentJson)
144 if err != nil {
145 t.Errorf("Get(%v) error %v", in, err.Error())
146 }
147
148 if len(result.(map[string]interface{})) != TEST_NODE_OBJ_NB_ELEMENTS {
149 t.Errorf("Get(%v) = %v, expect full document", in, result)
150 }
151 }
152
153 func BenchmarkGet(b *testing.B) {
154 p, _ := NewJsonPointer(`/obj/d/1/f`)
155 b.ResetTimer()
156 for i := 0; i < b.N; i++ {
157 p.Get(testDocumentJson)
158 }
159 }
160
161 func TestArray(t *testing.T) {
162
163 ins := []string{`/foo/0`, `/foo/0`, `/foo/1`}
164 outs := []string{"bar", "bar", "baz"}
165
166 for i := range ins {
167
168 p, err := NewJsonPointer(ins[i])
169 if err != nil {
170 t.Errorf("NewJsonPointer(%v) error %v", ins[i], err.Error())
171 }
172
173 result, _, err := p.Get(testDocumentJson)
174 if err != nil {
175 t.Errorf("Get(%v) error %v", ins[i], err.Error())
176 }
177
178 if result != outs[i] {
179 t.Errorf("Get(%v) = %v, expect %v", ins[i], result, outs[i])
180 }
181 }
182
183 }
184
185 func TestObject(t *testing.T) {
186
187 ins := []string{`/obj/a`, `/obj/b`, `/obj/c/0`, `/obj/c/1`, `/obj/c/1`, `/obj/d/1/f/0`}
188 outs := []float64{1, 2, 3, 4, 4, 50}
189
190 for i := range ins {
191
192 p, err := NewJsonPointer(ins[i])
193 if err != nil {
194 t.Errorf("NewJsonPointer(%v) error %v", ins[i], err.Error())
195 }
196
197 result, _, err := p.Get(testDocumentJson)
198 if err != nil {
199 t.Errorf("Get(%v) error %v", ins[i], err.Error())
200 }
201
202 if result != outs[i] {
203 t.Errorf("Get(%v) = %v, expect %v", ins[i], result, outs[i])
204 }
205 }
206
207 }
208
209 func TestSetNode(t *testing.T) {
210
211 jsonText := `{"a":[{"b": 1, "c": 2}], "d": 3}`
212
213 var jsonDocument interface{}
214 json.Unmarshal([]byte(jsonText), &jsonDocument)
215
216 in := "/a/0/c"
217
218 p, err := NewJsonPointer(in)
219 if err != nil {
220 t.Errorf("NewJsonPointer(%v) error %v", in, err.Error())
221 }
222
223 _, err = p.Set(jsonDocument, 999)
224 if err != nil {
225 t.Errorf("Set(%v) error %v", in, err.Error())
226 }
227
228 firstNode := jsonDocument.(map[string]interface{})
229 if len(firstNode) != 2 {
230 t.Errorf("Set(%s) failed", in)
231 }
232
233 sliceNode := firstNode["a"].([]interface{})
234 if len(sliceNode) != 1 {
235 t.Errorf("Set(%s) failed", in)
236 }
237
238 changedNode := sliceNode[0].(map[string]interface{})
239 changedNodeValue := changedNode["c"].(int)
240
241 if changedNodeValue != 999 {
242 if len(sliceNode) != 1 {
243 t.Errorf("Set(%s) failed", in)
244 }
245 }
246
247 }
248
249 func TestSetEmptyNode(t *testing.T) {
250
251 jsonText := `{}`
252
253 var jsonDocument interface{}
254 json.Unmarshal([]byte(jsonText), &jsonDocument)
255
256 in := "/a"
257
258 p, err := NewJsonPointer(in)
259 if err != nil {
260 t.Errorf("NewJsonPointer(%v) error %v", in, err.Error())
261 }
262
263 _, err = p.Set(jsonDocument, 999)
264 if err != nil {
265 t.Errorf("Set(%v) error %v", in, err.Error())
266 }
267
268 firstNode := jsonDocument.(map[string]interface{})
269 target := firstNode["a"].(int)
270 if target != 999 {
271 t.Errorf("Set(%s) failed", in)
272 }
273 }
274
275 func TestDelObject(t *testing.T) {
276 jsonText := `{
277 "a":["apple sauce", "ketchup", "soy sauce"],
278 "d": {
279 "z" : {
280 "v" : {
281 "name" : "donald mcbobble",
282 "occupation" : "corporate overlord"
283 }
284 }
285 }
286 }`
287
288 var jsonDocument map[string]interface{}
289 json.Unmarshal([]byte(jsonText), &jsonDocument)
290
291
292 in := "/d/z/v/occupation"
293 p, err := NewJsonPointer(in)
294 if err != nil {
295 t.Errorf("NewJsonPointer(%v) error %v", in, err.Error())
296 }
297
298 _, err = p.Delete(jsonDocument)
299 if err != nil {
300 t.Errorf("Delete(%v) error %v", in, err.Error())
301 }
302
303 var d map[string]interface{} = jsonDocument["d"].(map[string]interface{})
304 var z map[string]interface{} = d["z"].(map[string]interface{})
305 var v map[string]interface{} = z["v"].(map[string]interface{})
306
307 if _, present := v["occupation"]; present {
308 t.Errorf("Delete (%s) failed: key is still present in the map", in)
309 }
310 }
311
312 func TestDelArray(t *testing.T) {
313 jsonText := `{
314 "a":["applesauce", "ketchup", "soysauce", "oliveoil"],
315 "d": {
316 "z" : {
317 "v" : {
318 "name" : "donald mcbobble",
319 "occupation" : "corporate overlord",
320 "responsibilities" : ["managing", "hiring"]
321 }
322 }
323 }
324 }`
325
326 var jsonDocument map[string]interface{}
327 json.Unmarshal([]byte(jsonText), &jsonDocument)
328
329
330 in := "/a/2"
331 p, err := NewJsonPointer(in)
332 if err != nil {
333 t.Errorf("NewJsonPointer(%v) error %v", in, err.Error())
334 }
335
336 _, err = p.Delete(jsonDocument)
337 if err != nil {
338 t.Errorf("Delete(%v) error %v", in, err.Error())
339 }
340
341 a := jsonDocument["a"].([]interface{})
342 if len(a) != 3 || a[2] == "soysauce" {
343 t.Errorf("Delete(%v) error (%s)", in, a)
344 }
345
346 }
347
View as plain text