kubelatte-ce

1
package location
2

3
import (
4
	"reflect"
5
	"testing"
6
)
7

8
func TestCompilePathToLocation(t *testing.T) {
9
	t.Parallel()
10
	type args struct {
11
		path string
12
	}
13
	tests := []struct {
14
		name    string
15
		args    args
16
		want    *Node
17
		wantErr bool
18
	}{
19
		{
20
			name: "ok",
21
			args: args{
22
				path: "test.generic[].name[@.name].value[@.name == `value`]",
23
			},
24
			want: &Node{
25
				nodeType: SimplePath,
26
				path:     "test",
27
				filter:   nil,
28
				child: &Node{
29
					nodeType: GenericFilter,
30
					path:     "generic",
31
					filter:   nil,
32
					child: &Node{
33
						nodeType: NameFilter,
34
						path:     "name",
35
						filter: &filter{
36
							name:  "name",
37
							value: "",
38
						},
39
						child: &Node{
40
							nodeType: ValueFilter,
41
							path:     "value",
42
							filter: &filter{
43
								name:  "name",
44
								value: "value",
45
							},
46
							child: &Node{},
47
						},
48
					},
49
				},
50
			},
51
			wantErr: false,
52
		},
53
	}
54
	for _, tt := range tests {
55
		t.Run(tt.name, func(t *testing.T) {
56
			got, err := CompilePathToLocation(tt.args.path)
57
			if (err != nil) != tt.wantErr {
58
				t.Errorf("CompilePathToLocation() error = %v, wantErr %v", err, tt.wantErr)
59
				return
60
			}
61
			if !reflect.DeepEqual(got, tt.want) {
62
				t.Errorf("CompilePathToLocation() got = %v, want %v", got, tt.want)
63
			}
64
		})
65
	}
66
}
67

68
func TestLocationNode_ReplaceByLocation(t *testing.T) {
69
	t.Parallel()
70
	type fields struct {
71
		nodeType NodeType
72
		path     string
73
		filter   *filter
74
		child    *Node
75
	}
76
	type args struct {
77
		target      map[string]interface{}
78
		replacement map[string]interface{}
79
		location    *Node
80
	}
81
	var tests = []struct {
82
		name    string
83
		fields  fields
84
		args    args
85
		want    map[string]interface{}
86
		wantErr bool
87
	}{
88
		{
89
			name: "simple path exists",
90
			fields: fields{
91
				nodeType: 0,
92
				path:     "test",
93
				filter:   nil,
94
				child:    &Node{},
95
			},
96
			args: args{
97
				target:      map[string]interface{}{"test": map[string]interface{}{}},
98
				replacement: map[string]interface{}{"res": nil},
99
				location:    nil,
100
			},
101
			want:    map[string]interface{}{"test": map[string]interface{}{"res": nil}},
102
			wantErr: false,
103
		},
104
		{
105
			name: "simple path doesnt exist",
106
			fields: fields{
107
				nodeType: SimplePath,
108
				path:     "dif",
109
				filter:   nil,
110
				child:    &Node{},
111
			},
112
			args: args{
113
				target:      map[string]interface{}{"test": map[string]interface{}{}},
114
				replacement: map[string]interface{}{"res": nil},
115
				location:    nil,
116
			},
117
			want:    map[string]interface{}{"dif": map[string]interface{}{"res": nil}, "test": map[string]interface{}{}},
118
			wantErr: false,
119
		},
120
		{
121
			name: "simple path is not a map",
122
			fields: fields{
123
				nodeType: SimplePath,
124
				path:     "dif",
125
				filter:   nil,
126
				child:    &Node{},
127
			},
128
			args: args{
129
				target:      map[string]interface{}{"dif": "string"},
130
				replacement: map[string]interface{}{"res": nil},
131
				location:    nil,
132
			},
133
			want:    map[string]interface{}{"dif": map[string]interface{}{"res": nil}},
134
			wantErr: false,
135
		},
136
		{
137
			name: "generic filter",
138
			fields: fields{
139
				nodeType: GenericFilter,
140
				path:     "test",
141
				child:    &Node{},
142
			},
143
			args: args{
144
				target:      map[string]interface{}{"test": []interface{}{map[string]interface{}{}}},
145
				replacement: map[string]interface{}{"test": "value"},
146
				location:    nil,
147
			},
148
			want:    map[string]interface{}{"test": []interface{}{map[string]interface{}{"test": "value"}}},
149
			wantErr: false,
150
		},
151
		{
152
			name: "generic filter, yaml error",
153
			fields: fields{
154
				nodeType: GenericFilter,
155
				path:     "test",
156
				child:    &Node{},
157
			},
158
			args: args{
159
				target:      map[string]interface{}{"test": []interface{}{nil}},
160
				replacement: map[string]interface{}{"test": "value"},
161
				location:    nil,
162
			},
163
			want:    map[string]interface{}{"test": []interface{}{map[string]interface{}{"test": "value"}}},
164
			wantErr: false,
165
		},
166
		{
167
			name: "generic filter not a list",
168
			fields: fields{
169
				nodeType: GenericFilter,
170
				path:     "test",
171
				child:    &Node{},
172
			},
173
			args: args{
174
				target:      map[string]interface{}{"test": map[string]interface{}{"test1": "value"}},
175
				replacement: map[string]interface{}{"test": "value"},
176
			},
177
			want:    map[string]interface{}{"test": map[string]interface{}{"test1": map[string]interface{}{"test": "value"}}},
178
			wantErr: false,
179
		},
180
		{
181
			name: "name filter",
182
			fields: fields{
183
				nodeType: NameFilter,
184
				path:     "test",
185
				child:    &Node{},
186
				filter:   &filter{name: "name"},
187
			},
188
			args: args{
189
				target:      map[string]interface{}{"test": []interface{}{map[string]interface{}{"name": "val"}, map[string]interface{}{"name2": "val2"}}},
190
				replacement: map[string]interface{}{"test": "value"},
191
				location:    nil,
192
			},
193
			want:    map[string]interface{}{"test": []interface{}{map[string]interface{}{"test": "value"}, map[string]interface{}{"name2": "val2"}}},
194
			wantErr: false,
195
		},
196
		{
197
			name: "name filter not a list",
198
			fields: fields{
199
				nodeType: NameFilter,
200
				path:     "test",
201
				child:    &Node{},
202
				filter:   &filter{name: "name"},
203
			},
204
			args: args{
205
				target:      map[string]interface{}{"test": map[string]interface{}{"d": "e"}},
206
				replacement: map[string]interface{}{"test": "value"},
207
			},
208
			want:    nil,
209
			wantErr: true,
210
		},
211
		{
212
			name: "name filter elements are not maps",
213
			fields: fields{
214
				nodeType: NameFilter,
215
				path:     "test",
216
				child:    &Node{},
217
				filter:   &filter{name: "name"},
218
			},
219
			args: args{
220
				target:      map[string]interface{}{"test": []interface{}{"not", "map"}},
221
				replacement: map[string]interface{}{"test": "value"},
222
				location:    nil,
223
			},
224
			want:    nil,
225
			wantErr: true,
226
		},
227
		{
228
			name: "value filter",
229
			fields: fields{
230
				nodeType: ValueFilter,
231
				path:     "test",
232
				child:    &Node{},
233
				filter:   &filter{name: "name", value: "value"},
234
			},
235
			args: args{
236
				target:      map[string]interface{}{"test": []interface{}{map[string]interface{}{"name": "value"}, map[string]interface{}{"name2": "val2"}}},
237
				replacement: map[string]interface{}{"test": "value"},
238
				location:    nil,
239
			},
240
			want:    map[string]interface{}{"test": []interface{}{map[string]interface{}{"test": "value"}, map[string]interface{}{"name2": "val2"}}},
241
			wantErr: false,
242
		},
243
		{
244
			name: "value filter elements are not a map",
245
			fields: fields{
246
				nodeType: ValueFilter,
247
				path:     "test",
248
				child:    &Node{},
249
				filter:   &filter{name: "name", value: "value"},
250
			},
251
			args: args{
252
				target:      map[string]interface{}{"test": []interface{}{"sdf", "sdf"}},
253
				replacement: map[string]interface{}{"test": "value"},
254
				location:    nil,
255
			},
256
			want:    nil,
257
			wantErr: true,
258
		},
259
		{
260
			name: "value filter not list",
261
			fields: fields{
262
				nodeType: ValueFilter,
263
				path:     "test",
264
				child:    &Node{},
265
				filter:   &filter{name: "name", value: "value"},
266
			},
267
			args: args{
268
				target:      map[string]interface{}{"test": "string"},
269
				replacement: map[string]interface{}{"test": "value"},
270
				location:    nil,
271
			},
272
			want:    nil,
273
			wantErr: true,
274
		},
275
	}
276
	for _, tt := range tests {
277
		t.Run(tt.name, func(t *testing.T) {
278
			l := &Node{
279
				nodeType: tt.fields.nodeType,
280
				path:     tt.fields.path,
281
				filter:   tt.fields.filter,
282
				child:    tt.fields.child,
283
			}
284
			got, err := l.ReplaceByLocation(tt.args.target, tt.args.replacement, l)
285
			if (err != nil) != tt.wantErr {
286
				t.Errorf("ReplaceByLocation() error = %v, wantErr %v", err, tt.wantErr)
287
				return
288
			}
289
			if !reflect.DeepEqual(got, tt.want) {
290
				t.Errorf("ReplaceByLocation() got = %v, want %v", got, tt.want)
291
			}
292
		})
293
	}
294
}
295

296
func TestLocationNode_GetLastItem(t *testing.T) {
297
	t.Parallel()
298
	type fields struct {
299
		nodeType NodeType
300
		path     string
301
		filter   *filter
302
		child    *Node
303
	}
304
	tests := []struct {
305
		name   string
306
		fields fields
307
		want   string
308
	}{
309
		{
310
			name: "ok",
311
			fields: fields{
312
				nodeType: 0,
313
				path:     "test",
314
				filter:   nil,
315
				child:    &Node{path: "last", child: &Node{}},
316
			},
317
			want: "last",
318
		},
319
	}
320
	for _, tt := range tests {
321
		t.Run(tt.name, func(t *testing.T) {
322
			l := &Node{
323
				nodeType: tt.fields.nodeType,
324
				path:     tt.fields.path,
325
				filter:   tt.fields.filter,
326
				child:    tt.fields.child,
327
			}
328
			if got := l.GetLastItem(); got != tt.want {
329
				t.Errorf("GetLastItem() = %v, want %v", got, tt.want)
330
			}
331
		})
332
	}
333
}
334

335
func TestLocationNode_MergeByLocation(t *testing.T) {
336
	t.Parallel()
337
	type fields struct {
338
		nodeType NodeType
339
		path     string
340
		filter   *filter
341
		child    *Node
342
	}
343
	type args struct {
344
		reference   interface{}
345
		replacement map[string]interface{}
346
		location    *Node
347
	}
348
	tests := []struct {
349
		name    string
350
		fields  fields
351
		args    args
352
		want    map[string]interface{}
353
		wantErr bool
354
	}{
355
		{
356
			name: "simple path exists",
357
			fields: fields{
358
				nodeType: 0,
359
				path:     "test",
360
				filter:   nil,
361
				child:    &Node{},
362
			},
363
			args: args{
364
				reference:   map[string]interface{}{"test": map[string]interface{}{}},
365
				replacement: map[string]interface{}{"res": nil},
366
			},
367
			want:    map[string]interface{}{"test": map[string]interface{}{"res": nil}},
368
			wantErr: false,
369
		},
370
		{
371
			name: "generic filter",
372
			fields: fields{
373
				nodeType: GenericFilter,
374
				path:     "test",
375
				child:    &Node{},
376
			},
377
			args: args{
378
				reference:   map[string]interface{}{"test": []interface{}{map[string]interface{}{}}},
379
				replacement: map[string]interface{}{"test": "value"},
380
			},
381
			want:    map[string]interface{}{"test": []interface{}{map[string]interface{}{"test": "value"}}},
382
			wantErr: false,
383
		},
384
		{
385
			name: "generic filter, yaml error",
386
			fields: fields{
387
				nodeType: GenericFilter,
388
				path:     "test",
389
				child:    &Node{},
390
			},
391
			args: args{
392
				reference:   map[string]interface{}{"test": []interface{}{nil}},
393
				replacement: map[string]interface{}{"test": "value"},
394
			},
395
			want:    nil,
396
			wantErr: true,
397
		},
398
		{
399
			name: "generic filter not a list",
400
			fields: fields{
401
				nodeType: GenericFilter,
402
				path:     "test",
403
				child:    &Node{},
404
			},
405
			args: args{
406
				reference:   map[string]interface{}{"test": map[string]interface{}{"test1": "value"}},
407
				replacement: map[string]interface{}{"test": "value"},
408
			},
409
			want:    map[string]interface{}{"test": map[string]interface{}{"test1": map[string]interface{}{"test": "value"}}},
410
			wantErr: false,
411
		},
412
		{
413
			name: "name filter",
414
			fields: fields{
415
				nodeType: NameFilter,
416
				path:     "test",
417
				child:    &Node{},
418
				filter:   &filter{name: "name"},
419
			},
420
			args: args{
421
				reference:   map[string]interface{}{"test": []interface{}{map[string]interface{}{"name": "val"}, map[string]interface{}{"name2": "val2"}}},
422
				replacement: map[string]interface{}{"test": "value"},
423
			},
424
			want:    map[string]interface{}{"test": []interface{}{map[string]interface{}{"name": "val", "test": "value"}}},
425
			wantErr: false,
426
		},
427
		{
428
			name: "name filter not a list",
429
			fields: fields{
430
				nodeType: NameFilter,
431
				path:     "test",
432
				child:    &Node{},
433
				filter:   &filter{name: "name"},
434
			},
435
			args: args{
436
				reference:   map[string]interface{}{"test": map[string]interface{}{"d": "e"}},
437
				replacement: map[string]interface{}{"test": "value"},
438
			},
439
			want:    nil,
440
			wantErr: true,
441
		},
442
		{
443
			name: "name filter elements are not maps",
444
			fields: fields{
445
				nodeType: NameFilter,
446
				path:     "test",
447
				child:    &Node{},
448
				filter:   &filter{name: "name"},
449
			},
450
			args: args{
451
				reference:   map[string]interface{}{"test": []interface{}{"not", "map"}},
452
				replacement: map[string]interface{}{"test": "value"},
453
			},
454
			want:    nil,
455
			wantErr: true,
456
		},
457
		{
458
			name: "value filter",
459
			fields: fields{
460
				nodeType: ValueFilter,
461
				path:     "test",
462
				child:    &Node{},
463
				filter:   &filter{name: "name", value: "value"},
464
			},
465
			args: args{
466
				reference:   map[string]interface{}{"test": []interface{}{map[string]interface{}{"name": "value"}, map[string]interface{}{"name2": "val2"}}},
467
				replacement: map[string]interface{}{"test": "value"},
468
			},
469
			want:    map[string]interface{}{"test": []interface{}{map[string]interface{}{"name": "value", "test": "value"}}},
470
			wantErr: false,
471
		},
472
		{
473
			name: "value filter elements are not a map",
474
			fields: fields{
475
				nodeType: ValueFilter,
476
				path:     "test",
477
				child:    &Node{},
478
				filter:   &filter{name: "name", value: "value"},
479
			},
480
			args: args{
481
				reference:   map[string]interface{}{"test": []interface{}{"sdf", "sdf"}},
482
				replacement: map[string]interface{}{"test": "value"},
483
			},
484
			want:    nil,
485
			wantErr: true,
486
		},
487
		{
488
			name: "value filter not list",
489
			fields: fields{
490
				nodeType: ValueFilter,
491
				path:     "test",
492
				child:    &Node{},
493
				filter:   &filter{name: "name", value: "value"},
494
			},
495
			args: args{
496
				reference:   map[string]interface{}{"test": "string"},
497
				replacement: map[string]interface{}{"test": "value"},
498
			},
499
			want:    nil,
500
			wantErr: true,
501
		},
502

503
		{
504
			name: "merge no matches",
505
			fields: fields{
506
				nodeType: ValueFilter,
507
				path:     "test",
508
				filter:   &filter{name: "name", value: "value2"},
509
				child:    &Node{},
510
			},
511
			args: args{
512
				reference:   map[string]interface{}{"test": []interface{}{map[string]interface{}{"name": "value"}, map[string]interface{}{"name2": "val2"}}},
513
				replacement: map[string]interface{}{"test": "value"},
514
				location:    nil,
515
			},
516
			want:    map[string]interface{}{"test": []interface{}{}},
517
			wantErr: false,
518
		},
519
		{
520
			name: "merge no matches",
521
			fields: fields{
522
				nodeType: ValueFilter,
523
				path:     "test",
524
				filter:   &filter{name: "name", value: "value2"},
525
				child:    &Node{},
526
			},
527
			args: args{
528
				reference:   map[string]interface{}{"test": []interface{}{map[string]interface{}{"name": "value"}, map[string]interface{}{"name": "value2"}}},
529
				replacement: map[string]interface{}{"test": "new_val"},
530
			},
531
			want:    map[string]interface{}{"test": []interface{}{map[string]interface{}{"name": "value2", "test": "new_val"}}},
532
			wantErr: false,
533
		},
534
		{
535
			name: "merge name filter",
536
			fields: fields{
537
				nodeType: NameFilter,
538
				path:     "test",
539
				filter:   &filter{name: "name"},
540
				child:    &Node{},
541
			},
542
			args: args{
543
				reference:   map[string]interface{}{"test": []interface{}{map[string]interface{}{"wrong": "value"}, map[string]interface{}{"name": "value2"}}},
544
				replacement: map[string]interface{}{"test": "new_val"},
545
			},
546
			want:    map[string]interface{}{"test": []interface{}{map[string]interface{}{"name": "value2", "test": "new_val"}}},
547
			wantErr: false,
548
		},
549
		{
550
			name: "test iterate",
551
			fields: fields{
552
				nodeType: GenericFilter,
553
				path:     "test",
554
				filter:   &filter{},
555
				child:    &Node{},
556
			},
557
			args: args{
558
				reference:   map[string]interface{}{"not_here": nil, "test": map[string]interface{}{"wrong": "value", "name": "value2"}},
559
				replacement: map[string]interface{}{"ez": "value"},
560
			},
561
			want:    map[string]interface{}{"test": map[string]interface{}{"wrong": map[string]interface{}{"ez": "value"}, "name": map[string]interface{}{"ez": "value"}}},
562
			wantErr: false,
563
		},
564
	}
565
	for _, tt := range tests {
566
		t.Run(tt.name, func(t *testing.T) {
567
			l := &Node{
568
				nodeType: tt.fields.nodeType,
569
				path:     tt.fields.path,
570
				filter:   tt.fields.filter,
571
				child:    tt.fields.child,
572
			}
573
			got, err := l.MergeByLocation(tt.args.reference, tt.args.replacement, l)
574
			if (err != nil) != tt.wantErr {
575
				t.Errorf("MergeByLocation() error = %v, wantErr %v", err, tt.wantErr)
576
				return
577
			}
578
			if !reflect.DeepEqual(got, tt.want) {
579
				t.Errorf("MergeByLocation() got = %v, want %v", got, tt.want)
580
			}
581
		})
582
	}
583
}
584