kubelatte-ce

1
/*
2
 * Copyright (c) 2020, salesforce.com, inc.
3
 * All rights reserved.
4
 * SPDX-License-Identifier: BSD-3-Clause
5
 * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
6
 */
7

8
package util
9

10
import (
11
	"crypto/rand"
12
	"crypto/rsa"
13
	"crypto/x509"
14
	"crypto/x509/pkix"
15
	"encoding/pem"
16
	"fmt"
17
	"gitverse.ru/synapse/kubelatte/pkg/util/env"
18
	"math/big"
19
	"net"
20
	"os"
21
	"path/filepath"
22
	"testing"
23
	"time"
24

25
	"github.com/stretchr/testify/assert"
26
	corev1 "k8s.io/api/core/v1"
27
)
28

29
func TestGetAnnotation(t *testing.T) {
30
	assert.Equal(t, "annotation.io/key", GetAnnotation("annotation.io", "key"))
31
}
32

33
func TestMergeVolumes(t *testing.T) {
34
	target := []corev1.Volume{
35
		{
36
			Name: "one",
37
		},
38
		{
39
			Name: "two",
40
		},
41
	}
42
	added := []corev1.Volume{
43
		{
44
			Name: "two",
45
		},
46
		{
47
			Name: "three",
48
		},
49
	}
50
	merged := MergeVolumes(target, added)
51

52
	assert.Len(t, merged, 3)
53
	assert.Equal(t, "one", merged[0].Name)
54
	assert.Equal(t, "two", merged[1].Name)
55
	assert.Equal(t, "three", merged[2].Name)
56
}
57

58
func TestMergeVolumeMounts(t *testing.T) {
59
	target := []corev1.VolumeMount{
60
		{
61
			Name: "one",
62
		},
63
		{
64
			Name: "two",
65
		},
66
	}
67
	added := []corev1.VolumeMount{
68
		{
69
			Name: "one",
70
		},
71
	}
72
	merged := MergeVolumeMounts(target, added)
73

74
	assert.Len(t, merged, 2)
75
	assert.Equal(t, "one", merged[0].Name)
76
	assert.Equal(t, "two", merged[1].Name)
77
}
78

79
func TestMergeVolumeMountsNoDuplicates(t *testing.T) {
80
	target := []corev1.VolumeMount{
81
		{
82
			Name: "one",
83
		},
84
		{
85
			Name: "two",
86
		},
87
	}
88
	added := []corev1.VolumeMount{
89
		{
90
			Name: "three",
91
		},
92
		{
93
			Name: "four",
94
		},
95
	}
96
	merged := MergeVolumeMounts(target, added)
97

98
	assert.Len(t, merged, 4)
99
	assert.Equal(t, "one", merged[0].Name)
100
	assert.Equal(t, "two", merged[1].Name)
101
	assert.Equal(t, "three", merged[2].Name)
102
	assert.Equal(t, "four", merged[3].Name)
103
}
104
func TestDeDuplicateVolumeMounts(t *testing.T) {
105
	target := []corev1.VolumeMount{
106
		{
107
			Name: "one",
108
		},
109
		{
110
			Name: "three",
111
		},
112
	}
113
	added := []corev1.VolumeMount{
114
		{
115
			Name: "three",
116
		},
117
		{
118
			Name: "four",
119
		},
120
	}
121
	merged := DeDuplicateVolumeMounts(target, added)
122

123
	assert.Len(t, merged, 1)
124
	assert.Equal(t, "four", merged[0].Name)
125
}
126

127
func TestDeDuplicateContainers(t *testing.T) {
128
	target := []corev1.Container{
129
		{
130
			Name: "one",
131
		},
132
		{
133
			Name: "three",
134
		},
135
	}
136
	added := []corev1.Container{
137
		{
138
			Name: "three",
139
		},
140
		{
141
			Name: "four",
142
		},
143
	}
144
	merged := DeDuplicateContainers(target, added)
145

146
	assert.Len(t, merged, 1)
147
	assert.Equal(t, "four", merged[0].Name)
148
}
149

150
// TempCerts for temporary certificates
151
type TempCerts struct {
152
	certsDirectory string
153
	certFileName   string
154
	keyFileName    string
155
}
156

157
// GenerateTestCertificates generates test certificates
158
func GenerateTestCertificates() (*TempCerts, error) {
159
	// Source - https://golang.org/src/crypto/tls/generate_cert.go
160

161
	var err error
162
	tempDir := os.TempDir()
163
	if err != nil {
164
		return nil, fmt.Errorf("failed to create a temp directory: %s", err)
165
	}
166

167
	certFileName := filepath.Join(tempDir, "cert.pem")
168
	keyFileName := filepath.Join(tempDir, "key.pem")
169

170
	var privateKey *rsa.PrivateKey
171
	privateKey, err = rsa.GenerateKey(rand.Reader, 2048)
172

173
	if err != nil {
174
		return nil, fmt.Errorf("failed to generate private key: %s", err)
175
	}
176

177
	notBefore := time.Now()
178
	notAfter := notBefore.Add(365 * 24 * time.Hour)
179

180
	serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
181
	serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
182

183
	if err != nil {
184
		return nil, fmt.Errorf("failed to generate serial number: %s", err)
185
	}
186

187
	template := x509.Certificate{
188
		SerialNumber: serialNumber,
189
		Subject: pkix.Name{
190
			Organization: []string{"Salesforce.com"},
191
		},
192
		NotBefore: notBefore,
193
		NotAfter:  notAfter,
194

195
		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
196
		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
197
		BasicConstraintsValid: true,
198
		IPAddresses:           []net.IP{net.IPv4(127, 0, 0, 1)},
199
		DNSNames:              []string{"localhost"},
200
	}
201

202
	publicKey := &privateKey.PublicKey
203
	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, publicKey, privateKey)
204
	if err != nil {
205
		return nil, fmt.Errorf("failed to create certificate: %s", err)
206
	}
207

208
	err = writePemBlockToFile(certFileName, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
209
	if err != nil {
210
		return nil, err
211
	}
212

213
	err = writePemBlockToFile(keyFileName, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(privateKey)})
214
	if err != nil {
215
		return nil, err
216
	}
217

218
	return &TempCerts{
219
		certsDirectory: tempDir,
220
		certFileName:   certFileName,
221
		keyFileName:    keyFileName,
222
	}, nil
223
}
224

225
func writePemBlockToFile(fileName string, pemBlock *pem.Block) error {
226
	certOut, err := os.Create(fileName)
227
	if err != nil {
228
		return fmt.Errorf("failed to create %s: %s", fileName, err)
229
	}
230

231
	if err := pem.Encode(certOut, pemBlock); err != nil {
232
		return fmt.Errorf("failed to write block to file: %s", err)
233
	}
234

235
	if err := certOut.Close(); err != nil {
236
		return fmt.Errorf("unable to close %s: %s", fileName, err)
237
	}
238

239
	return nil
240
}
241

242
func TestIsFullRole(t *testing.T) {
243
	tests := []struct {
244
		name string
245
		f    func()
246
		def  func()
247
		want bool
248
	}{
249
		{
250
			name: "full role",
251
			f: func() {
252
				env.KbltMutator = true
253
				env.KbltValidator = true
254
			},
255
			def: func() {
256
				env.KbltMutator = false
257
				env.KbltValidator = false
258
			},
259
			want: true,
260
		},
261
		{
262
			name: "not full role 1",
263
			f: func() {
264
				env.KbltMutator = true
265
				env.KbltValidator = false
266
			},
267
			def: func() {
268
				env.KbltMutator = false
269
				env.KbltValidator = false
270
			},
271
			want: false,
272
		},
273
		{
274
			name: "not full role 2",
275
			f: func() {
276
				env.KbltMutator = false
277
				env.KbltValidator = true
278
			},
279
			def: func() {
280
				env.KbltMutator = false
281
				env.KbltValidator = false
282
			},
283
			want: false,
284
		},
285
		{
286
			name: "not full role 3",
287
			f: func() {
288
				env.KbltMutator = false
289
				env.KbltValidator = false
290
			},
291
			def: func() {
292
				env.KbltMutator = false
293
				env.KbltValidator = false
294
			},
295
			want: false,
296
		},
297
	}
298
	for _, tt := range tests {
299
		t.Run(tt.name, func(t *testing.T) {
300
			tt.f()
301
			defer tt.def()
302
			assert.Equalf(t, tt.want, IsFullRole(), "IsFullRole()")
303
		})
304
	}
305
}
306

307
func TestGetFunctionName(t *testing.T) {
308
	type args struct {
309
		i interface{}
310
	}
311
	tests := []struct {
312
		name string
313
		args args
314
		want string
315
	}{
316
		{
317
			name: "ok",
318
			args: args{i: SomeFuncName},
319
			want: "gitverse.ru/synapse/kubelatte/pkg/util.SomeFuncName",
320
		},
321
	}
322
	for _, tt := range tests {
323
		t.Run(tt.name, func(t *testing.T) {
324
			assert.Equalf(t, tt.want, GetFunctionName(tt.args.i), "GetFunctionName(%v)", tt.args.i)
325
		})
326
	}
327
}
328

329
func SomeFuncName() {}
330

331
func TestMergeStruct(t *testing.T) {
332
	type args struct {
333
		aT map[string]interface{}
334
		aS map[string]interface{}
335
	}
336
	tests := []struct {
337
		name string
338
		args args
339
		want map[string]interface{}
340
	}{
341
		{
342
			name: "case 1",
343
			args: args{
344
				aT: map[string]interface{}{
345
					"data": map[string]interface{}{
346
						"1": "val1",
347
						"2": []string{
348
							"2", "2",
349
						},
350
						"5": []interface{}{1, 2, 3},
351
					},
352
				},
353
				aS: map[string]interface{}{
354
					"data": map[string]interface{}{
355
						"3": "val3",
356
						"4": "val4",
357
						"5": []interface{}{4, 5, 6},
358
					},
359
				},
360
			},
361
			want: map[string]interface{}{
362
				"data": map[string]interface{}{
363
					"1": "val1",
364
					"2": []string{"2", "2"},
365
					"3": "val3",
366
					"4": "val4",
367
					"5": []interface{}{1, 2, 3, 4, 5, 6},
368
				},
369
			},
370
		},
371
	}
372
	for _, tt := range tests {
373
		t.Run(tt.name, func(t *testing.T) {
374
			assert.Equalf(t, tt.want, MergeStruct(tt.args.aT, tt.args.aS, true), "MergeStruct(%v, %v)", tt.args.aT, tt.args.aS)
375
		})
376
	}
377
}
378

379
func TestMergeSlice(t *testing.T) {
380
	type args struct {
381
		aT []interface{}
382
		aS []interface{}
383
	}
384
	tests := []struct {
385
		name string
386
		args args
387
		want []interface{}
388
	}{
389
		{
390
			name: "case_1",
391
			args: args{
392
				aT: []interface{}{
393
					map[string]interface{}{
394
						"name": "pompom",
395
					},
396
				},
397
				aS: []interface{}{
398
					map[string]interface{}{
399
						"name": "pompompo",
400
					}},
401
			},
402
			want: []interface{}{
403
				map[string]interface{}{"name": "pompom"},
404
				map[string]interface{}{"name": "pompompo"}},
405
		},
406
		{
407
			name: "case_2_same_values",
408
			args: args{
409
				aT: []interface{}{
410
					map[string]interface{}{
411
						"name": "pompom",
412
					},
413
				},
414
				aS: []interface{}{
415
					map[string]interface{}{
416
						"name": "pompom",
417
					}},
418
			},
419
			want: []interface{}{
420
				map[string]interface{}{"name": "pompom"}},
421
		},
422
		{
423
			name: "case_3_no_name",
424
			args: args{
425
				aT: []interface{}{
426
					map[string]interface{}{
427
						"momomo": "pompom",
428
					},
429
				},
430
				aS: []interface{}{
431
					map[string]interface{}{
432
						"momomo": "pompom",
433
					}},
434
			},
435
			want: []interface{}{
436
				map[string]interface{}{"momomo": "pompom"},
437
				map[string]interface{}{"momomo": "pompom"}},
438
		},
439
		{
440
			name: "case_3_no_map",
441
			args: args{
442
				aT: []interface{}{1},
443
				aS: []interface{}{1},
444
			},
445
			want: []interface{}{1, 1},
446
		},
447
	}
448
	for _, tt := range tests {
449
		t.Run(tt.name, func(t *testing.T) {
450
			assert.Equalf(t, tt.want, MergeSlice(tt.args.aT, tt.args.aS), "MergeSlice(%v, %v)", tt.args.aT, tt.args.aS)
451
		})
452
	}
453
}
454

455
func TestWrapString(t *testing.T) {
456
	type args struct {
457
		field  string
458
		render string
459
	}
460
	tests := []struct {
461
		name string
462
		args args
463
		want string
464
	}{
465
		{
466
			name: "ok",
467
			args: args{
468
				field:  "root",
469
				render: "item",
470
			},
471
			want: "root: item",
472
		},
473
	}
474
	for _, tt := range tests {
475
		t.Run(tt.name, func(t *testing.T) {
476
			assert.Equalf(t, tt.want, WrapString(tt.args.field, tt.args.render), "WrapString(%v, %v)", tt.args.field, tt.args.render)
477
		})
478
	}
479
}
480

481
func TestWrapList(t *testing.T) {
482
	type args struct {
483
		field  string
484
		render string
485
	}
486
	tests := []struct {
487
		name string
488
		args args
489
		want string
490
	}{
491
		{
492
			name: "ok",
493
			args: args{
494
				field:  "root",
495
				render: "-first\n-second",
496
			},
497
			want: "root:\n\n  -first\n  -second",
498
		},
499
		{
500
			name: "ok2",
501
			args: args{
502
				field:  "root",
503
				render: "\n-first \n-second",
504
			},
505
			want: "root:\n\n  -first \n  -second",
506
		},
507
	}
508
	for _, tt := range tests {
509
		t.Run(tt.name, func(t *testing.T) {
510
			assert.Equalf(t, tt.want, WrapList(tt.args.field, tt.args.render), "WrapList(%v, %v)", tt.args.field, tt.args.render)
511
		})
512
	}
513
}
514