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 TestMergeStruct(t *testing.T) {
308
	type args struct {
309
		aT map[string]interface{}
310
		aS map[string]interface{}
311
	}
312
	tests := []struct {
313
		name string
314
		args args
315
		want map[string]interface{}
316
	}{
317
		{
318
			name: "case 1",
319
			args: args{
320
				aT: map[string]interface{}{
321
					"data": map[string]interface{}{
322
						"1": "val1",
323
						"2": []string{
324
							"2", "2",
325
						},
326
						"5": []interface{}{1, 2, 3},
327
					},
328
				},
329
				aS: map[string]interface{}{
330
					"data": map[string]interface{}{
331
						"3": "val3",
332
						"4": "val4",
333
						"5": []interface{}{4, 5, 6},
334
					},
335
				},
336
			},
337
			want: map[string]interface{}{
338
				"data": map[string]interface{}{
339
					"1": "val1",
340
					"2": []string{"2", "2"},
341
					"3": "val3",
342
					"4": "val4",
343
					"5": []interface{}{1, 2, 3, 4, 5, 6},
344
				},
345
			},
346
		},
347
	}
348
	for _, tt := range tests {
349
		t.Run(tt.name, func(t *testing.T) {
350
			assert.Equalf(t, tt.want, MergeStruct(tt.args.aT, tt.args.aS, true), "MergeStruct(%v, %v)", tt.args.aT, tt.args.aS)
351
		})
352
	}
353
}
354

355
func TestMergeSlice(t *testing.T) {
356
	type args struct {
357
		aT []interface{}
358
		aS []interface{}
359
	}
360
	tests := []struct {
361
		name string
362
		args args
363
		want []interface{}
364
	}{
365
		{
366
			name: "case_1",
367
			args: args{
368
				aT: []interface{}{
369
					map[string]interface{}{
370
						"name": "pompom",
371
					},
372
				},
373
				aS: []interface{}{
374
					map[string]interface{}{
375
						"name": "pompompo",
376
					}},
377
			},
378
			want: []interface{}{
379
				map[string]interface{}{"name": "pompom"},
380
				map[string]interface{}{"name": "pompompo"}},
381
		},
382
		{
383
			name: "case_2_same_values",
384
			args: args{
385
				aT: []interface{}{
386
					map[string]interface{}{
387
						"name": "pompom",
388
					},
389
				},
390
				aS: []interface{}{
391
					map[string]interface{}{
392
						"name": "pompom",
393
					}},
394
			},
395
			want: []interface{}{
396
				map[string]interface{}{"name": "pompom"}},
397
		},
398
		{
399
			name: "case_3_no_name",
400
			args: args{
401
				aT: []interface{}{
402
					map[string]interface{}{
403
						"momomo": "pompom",
404
					},
405
				},
406
				aS: []interface{}{
407
					map[string]interface{}{
408
						"momomo": "pompom",
409
					}},
410
			},
411
			want: []interface{}{
412
				map[string]interface{}{"momomo": "pompom"},
413
				map[string]interface{}{"momomo": "pompom"}},
414
		},
415
		{
416
			name: "case_3_no_map",
417
			args: args{
418
				aT: []interface{}{1},
419
				aS: []interface{}{1},
420
			},
421
			want: []interface{}{1, 1},
422
		},
423
	}
424
	for _, tt := range tests {
425
		t.Run(tt.name, func(t *testing.T) {
426
			assert.Equalf(t, tt.want, MergeSlice(tt.args.aT, tt.args.aS), "MergeSlice(%v, %v)", tt.args.aT, tt.args.aS)
427
		})
428
	}
429
}
430

431
func TestWrapString(t *testing.T) {
432
	type args struct {
433
		field  string
434
		render string
435
	}
436
	tests := []struct {
437
		name string
438
		args args
439
		want string
440
	}{
441
		{
442
			name: "ok",
443
			args: args{
444
				field:  "root",
445
				render: "item",
446
			},
447
			want: "root: item",
448
		},
449
	}
450
	for _, tt := range tests {
451
		t.Run(tt.name, func(t *testing.T) {
452
			assert.Equalf(t, tt.want, WrapString(tt.args.field, tt.args.render), "WrapString(%v, %v)", tt.args.field, tt.args.render)
453
		})
454
	}
455
}
456

457
func TestWrapList(t *testing.T) {
458
	type args struct {
459
		field  string
460
		render string
461
	}
462
	tests := []struct {
463
		name string
464
		args args
465
		want string
466
	}{
467
		{
468
			name: "ok",
469
			args: args{
470
				field:  "root",
471
				render: "-first\n-second",
472
			},
473
			want: "root:\n\n  -first\n  -second",
474
		},
475
		{
476
			name: "ok2",
477
			args: args{
478
				field:  "root",
479
				render: "\n-first \n-second",
480
			},
481
			want: "root:\n\n  -first \n  -second",
482
		},
483
	}
484
	for _, tt := range tests {
485
		t.Run(tt.name, func(t *testing.T) {
486
			assert.Equalf(t, tt.want, WrapList(tt.args.field, tt.args.render), "WrapList(%v, %v)", tt.args.field, tt.args.render)
487
		})
488
	}
489
}
490