kubelatte-ce

1
package storage
2

3
import (
4
	"github.com/nuttech/bell"
5
	"github.com/open-policy-agent/opa/rego"
6
	"github.com/stretchr/testify/mock"
7
	"gitverse.ru/ktrntrsv/kubelatte-ce/pkg/api/v1alpha1"
8
	"gitverse.ru/ktrntrsv/kubelatte-ce/pkg/observability/logger/lib"
9
	"gitverse.ru/ktrntrsv/kubelatte-ce/pkg/operator/controllers/clientset"
10
	"gitverse.ru/ktrntrsv/kubelatte-ce/pkg/operator/controllers/clientset/mocks"
11
	"gitverse.ru/ktrntrsv/kubelatte-ce/pkg/operator/utils"
12
	"gitverse.ru/ktrntrsv/kubelatte-ce/pkg/util/env"
13
	"go.uber.org/zap"
14
	corev1 "k8s.io/api/core/v1"
15
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
16
	"k8s.io/client-go/rest"
17
	"reflect"
18
	"sync"
19
	"testing"
20
	"time"
21
)
22

23
func TestStorageController_Start(t *testing.T) {
24
	type args struct {
25
		withInit   bool
26
		senderMode bool
27
	}
28
	tests := []struct {
29
		name string
30
		args args
31
	}{
32
		{
33
			name: "ok",
34
			args: args{
35
				withInit:   true,
36
				senderMode: true,
37
			},
38
		},
39
	}
40
	for _, tt := range tests {
41
		t.Run(tt.name, func(t *testing.T) {
42
			lib.ZapLogger = zap.NewNop()
43
			var storageController = &StorageController{}
44
			storageController.Start(tt.args.senderMode, tt.args.senderMode)
45
			storageController.Stop()
46
		})
47
	}
48
}
49

50
func TestStorageController_UpdateTrigger(t *testing.T) {
51
	tests := []struct {
52
		name       string
53
		trigger    v1alpha1.Trigger
54
		senderMode bool
55
	}{
56
		{
57
			name: "ok",
58
			trigger: v1alpha1.Trigger{
59
				ObjectMeta: metav1.ObjectMeta{
60
					Name:      "trtr",
61
					Namespace: "123",
62
				},
63
			},
64
			senderMode: true,
65
		},
66
	}
67

68
	for _, tt := range tests {
69
		t.Run(tt.name, func(t *testing.T) {
70
			var eventSent bool
71
			defer func() { eventSent = false }()
72
			defer func() {
73
				if tt.senderMode {
74
					time.Sleep(100 * time.Millisecond)
75
					if !eventSent {
76
						t.Error("message was not sent with enabled senderMode")
77
					}
78
					return
79
				}
80
				if eventSent {
81
					t.Error("message was sent with disabled senderMode")
82
				}
83
			}()
84

85
			go func() {
86
				<-utils.SyncAddNewObject
87
				eventSent = true
88
				<-utils.SyncAddNewObject
89
				eventSent = true
90
			}()
91

92
			lib.ZapLogger = zap.NewNop()
93
			var storageController = &StorageController{}
94
			storageController.Start(false, tt.senderMode)
95
			storageController.UpdateTrigger(&tt.trigger)
96
			res, ok := storageController.triggers[tt.trigger.GetNamespacedName()]
97
			if !ok {
98
				t.Errorf("Trigger was not found")
99
			}
100
			if !reflect.DeepEqual(tt.trigger, res) {
101
				t.Errorf("Unexpected trigger value")
102
			}
103

104
			storageController.DeleteTrigger(&res)
105
			if _, ok := storageController.triggers[tt.trigger.GetNamespacedName()]; ok {
106
				t.Errorf("Trigger has not been deleted")
107
			}
108
		})
109
	}
110
}
111

112
func TestStorageController_UpdateTemplate(t *testing.T) {
113
	tests := []struct {
114
		name       string
115
		message    bell.Message
116
		template   v1alpha1.Template
117
		senderMode bool
118
	}{
119
		{
120
			name: "ok",
121
			template: v1alpha1.Template{
122
				ObjectMeta: metav1.ObjectMeta{
123
					Name:      "template",
124
					Namespace: "123",
125
				},
126
			},
127
			senderMode: true,
128
		},
129
	}
130
	for _, tt := range tests {
131
		t.Run(tt.name, func(t *testing.T) {
132
			var eventSent bool
133
			defer func() { eventSent = false }()
134
			defer func() {
135
				if tt.senderMode {
136
					time.Sleep(100 * time.Millisecond)
137
					if !eventSent {
138
						t.Error("message was not sent with enabled senderMode")
139
					}
140
					return
141
				}
142
				if eventSent {
143
					t.Error("message was sent with disabled senderMode")
144
				}
145
			}()
146

147
			go func() {
148
				<-utils.SyncAddNewObject
149
				eventSent = true
150
				<-utils.SyncAddNewObject
151
				eventSent = true
152
			}()
153

154
			lib.ZapLogger = zap.NewNop()
155
			var storageController = &StorageController{}
156
			storageController.Start(false, tt.senderMode)
157
			storageController.UpdateTemplate(&tt.template)
158
			res, ok := storageController.templates[tt.template.GetNamespacedName()]
159
			if !ok {
160
				t.Errorf("Template was not found")
161
			}
162
			if !reflect.DeepEqual(tt.template, res) {
163
				t.Errorf("Unexpected template value")
164
			}
165

166
			storageController.DeleteTemplate(&res)
167
			if _, ok := storageController.templates[tt.template.GetNamespacedName()]; ok {
168
				t.Errorf("Template has not been deleted")
169
			}
170
		})
171
	}
172
}
173

174
func TestStorageController_UpdateScope(t *testing.T) {
175
	tests := []struct {
176
		name       string
177
		message    bell.Message
178
		scope      v1alpha1.Scope
179
		senderMode bool
180
	}{
181
		{
182
			name: "ok",
183
			scope: v1alpha1.Scope{
184
				ObjectMeta: metav1.ObjectMeta{
185
					Name:      "scope",
186
					Namespace: "123",
187
				},
188
			},
189
			senderMode: true,
190
		},
191
	}
192
	for _, tt := range tests {
193
		t.Run(tt.name, func(t *testing.T) {
194
			var eventSent bool
195
			defer func() { eventSent = false }()
196
			defer func() {
197
				if tt.senderMode {
198
					time.Sleep(100 * time.Millisecond)
199
					if !eventSent {
200
						t.Error("message was not sent with enabled senderMode")
201
					}
202
					return
203
				}
204
				if eventSent {
205
					t.Error("message was sent with disabled senderMode")
206
				}
207
			}()
208

209
			go func() {
210
				<-utils.SyncAddNewObject
211
				eventSent = true
212
				<-utils.SyncAddNewObject
213
				eventSent = true
214
			}()
215

216
			lib.ZapLogger = zap.NewNop()
217
			var storageController = &StorageController{}
218
			storageController.Start(false, tt.senderMode)
219
			storageController.UpdateScope(tt.scope)
220
			res, ok := storageController.scopes[tt.scope.GetNamespacedName()]
221
			if !ok {
222
				t.Errorf("Scope was not found")
223
			}
224
			if !reflect.DeepEqual(tt.scope, res) {
225
				t.Errorf("Unexpected scope value")
226
			}
227

228
			storageController.GetScopeItems("")
229

230
			storageController.DeleteScope(tt.scope)
231
			if _, ok := storageController.scopes[tt.scope.GetNamespacedName()]; ok {
232
				t.Errorf("Scope has not been deleted")
233
			}
234
		})
235
	}
236
}
237

238
func TestStorageController_UpdateNamespace(t *testing.T) {
239
	tests := []struct {
240
		name       string
241
		message    bell.Message
242
		namespace  corev1.Namespace
243
		senderMode bool
244
	}{
245
		{
246
			name: "ok",
247
			namespace: corev1.Namespace{
248
				ObjectMeta: metav1.ObjectMeta{
249
					Name:      "namespace",
250
					Namespace: "123",
251
				},
252
			},
253
			senderMode: true,
254
		},
255
	}
256
	for _, tt := range tests {
257
		t.Run(tt.name, func(t *testing.T) {
258
			var eventSent bool
259
			defer func() { eventSent = false }()
260
			defer func() {
261
				if tt.senderMode {
262
					time.Sleep(100 * time.Millisecond)
263

264
					if !eventSent {
265
						t.Error("message was not sent with enabled senderMode")
266
					}
267
					return
268
				}
269
				if eventSent {
270
					t.Error("message was sent with disabled senderMode")
271
				}
272
			}()
273

274
			go func() {
275
				<-utils.SyncAddNewObject
276
				eventSent = true
277
				<-utils.SyncAddNewObject
278
				eventSent = true
279
			}()
280

281
			lib.ZapLogger = zap.NewNop()
282
			var storageController = &StorageController{}
283
			storageController.Start(false, tt.senderMode)
284
			storageController.UpdateNamespace(tt.namespace)
285
			res, ok := storageController.namespaces[tt.namespace.ObjectMeta.Name]
286
			if !ok {
287
				t.Errorf("Namespace was not found")
288
			}
289
			if !reflect.DeepEqual(tt.namespace, res) {
290
				t.Errorf("Unexpected namespace value")
291
			}
292

293
			storageController.DeleteNamespace(res)
294
			if _, ok := storageController.namespaces[tt.namespace.Namespace]; ok {
295
				t.Errorf("Namespace has not been deleted")
296
			}
297
		})
298
	}
299
}
300

301
func TestStorageController_GetResources(t *testing.T) {
302
	var storageController = &StorageController{}
303
	storageController.Start(false, false)
304
	storageController.GetScopes()
305
	storageController.GetTemplates()
306
	storageController.GetTriggers()
307
	storageController.GetNamespaces()
308
	storageController.GetScopeItems("validate")
309
}
310

311
func TestStorageController_CheckTriggerTemplatePair(t *testing.T) {
312
	tests := []struct {
313
		name      string
314
		triggers  map[string]v1alpha1.Trigger
315
		templates map[string]v1alpha1.Template
316
	}{
317
		{
318
			name: "ok",
319
			triggers: map[string]v1alpha1.Trigger{
320
				"triggerName": {Spec: v1alpha1.TriggerSpec{
321
					CreationConfigs: []v1alpha1.CreationConfig{
322
						{
323
							TemplateRefs: []string{"ref", "rrref"},
324
						},
325
					},
326
				}},
327
			},
328
			templates: map[string]v1alpha1.Template{"ref": {}},
329
		},
330
	}
331
	for _, tt := range tests {
332
		t.Run(tt.name, func(t *testing.T) {
333
			lib.ZapLogger = zap.NewNop()
334

335
			r := &StorageController{
336
				triggers:  tt.triggers,
337
				templates: tt.templates,
338
			}
339
			r.CheckTriggerTemplatePair()
340
		})
341
	}
342
}
343

344
func TestStorageController_InitStorage(t *testing.T) {
345
	startKbltCreator := env.KbltCreator
346
	startKbltMutator := env.KbltMutator
347
	startKbltValidator := env.KbltValidator
348

349
	defer func() {
350
		env.KbltCreator = startKbltCreator
351
		env.KbltMutator = startKbltMutator
352
		env.KbltValidator = startKbltValidator
353
	}()
354

355
	env.KbltCreator = true
356
	env.KbltMutator = true
357
	env.KbltValidator = true
358

359
	lib.ZapLogger = zap.NewNop()
360

361
	restCli := mocks.NewInterface(t)
362
	restCli.On("Get", mock.Anything).Return(&rest.Request{}).Maybe()
363

364
	triggerCli := mocks.NewTriggerInterface(t)
365
	triggerCli.On("List", mock.Anything, mock.Anything).
366
		Return(&v1alpha1.TriggerList{Items: []v1alpha1.Trigger{{
367
			ObjectMeta: metav1.ObjectMeta{
368
				Name:      "trig",
369
				Namespace: "123",
370
			}}}}, nil,
371
		).Maybe()
372

373
	templCli := mocks.NewTemplateInterface(t)
374
	templCli.On("List", mock.Anything, mock.Anything).
375
		Return(&v1alpha1.TemplateList{Items: []v1alpha1.Template{{
376
			ObjectMeta: metav1.ObjectMeta{
377
				Name:      "templ",
378
				Namespace: "123"},
379
		}}}, nil).Maybe()
380

381
	scopeCli := mocks.NewScopeInterface(t)
382
	scopeCli.On("List", mock.Anything, mock.Anything).
383
		Return(&v1alpha1.ScopeList{Items: []v1alpha1.Scope{{
384
			ObjectMeta: metav1.ObjectMeta{
385
				Name:      "scope",
386
				Namespace: "123"},
387
		}}}, nil).Maybe()
388

389
	triggerInsCli := mocks.NewTriggerInstanceInterface(t)
390

391
	utils.Cl = &clientset.V1Alpha1Client{
392
		TemplateClient:        templCli,
393
		TriggerClient:         triggerCli,
394
		ScopeClient:           scopeCli,
395
		TriggerInstanceClient: triggerInsCli,
396
		RestClient:            restCli,
397
	}
398

399
	r := &StorageController{}
400
	r.Start(true, false)
401
	r.Stop()
402
	utils.Cl = nil
403
}
404

405
func TestStorageController_DeleteRegoRule(t *testing.T) {
406
	r := &StorageController{
407
		regoRules: map[string]rego.PreparedEvalQuery{"name": {}},
408
		mutex:     sync.Mutex{},
409
	}
410
	r.DeleteRegoRule("name")
411
}
412

413
func TestStorageController_UpdateRegoRule(t *testing.T) {
414
	r := &StorageController{
415
		regoRules: map[string]rego.PreparedEvalQuery{"name": {}},
416
		mutex:     sync.Mutex{},
417
	}
418
	r.UpdateRegoRule("name", v1alpha1.TemplateSpec{Data: ""})
419
}
420