kubelatte-ce
Форк от sbertech/kubelatte-ce
419 строк · 9.9 Кб
1package storage
2
3import (
4"github.com/nuttech/bell"
5"github.com/open-policy-agent/opa/rego"
6"github.com/stretchr/testify/mock"
7"gitverse.ru/synapse/kubelatte/pkg/api/v1alpha1"
8"gitverse.ru/synapse/kubelatte/pkg/observability/logger/lib"
9"gitverse.ru/synapse/kubelatte/pkg/operator/controllers/clientset"
10"gitverse.ru/synapse/kubelatte/pkg/operator/controllers/clientset/mocks"
11"gitverse.ru/synapse/kubelatte/pkg/operator/utils"
12"gitverse.ru/synapse/kubelatte/pkg/util/env"
13"go.uber.org/zap"
14corev1 "k8s.io/api/core/v1"
15metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
16"k8s.io/client-go/rest"
17"reflect"
18"sync"
19"testing"
20"time"
21)
22
23func TestStorageController_Start(t *testing.T) {
24type args struct {
25withInit bool
26senderMode bool
27}
28tests := []struct {
29name string
30args args
31}{
32{
33name: "ok",
34args: args{
35withInit: true,
36senderMode: true,
37},
38},
39}
40for _, tt := range tests {
41t.Run(tt.name, func(t *testing.T) {
42lib.ZapLogger = zap.NewNop()
43var storageController = &StorageController{}
44storageController.Start(tt.args.senderMode, tt.args.senderMode)
45storageController.Stop()
46})
47}
48}
49
50func TestStorageController_UpdateTrigger(t *testing.T) {
51tests := []struct {
52name string
53trigger v1alpha1.Trigger
54senderMode bool
55}{
56{
57name: "ok",
58trigger: v1alpha1.Trigger{
59ObjectMeta: metav1.ObjectMeta{
60Name: "trtr",
61Namespace: "123",
62},
63},
64senderMode: true,
65},
66}
67
68for _, tt := range tests {
69t.Run(tt.name, func(t *testing.T) {
70var eventSent bool
71defer func() { eventSent = false }()
72defer func() {
73if tt.senderMode {
74time.Sleep(100 * time.Millisecond)
75if !eventSent {
76t.Error("message was not sent with enabled senderMode")
77}
78return
79}
80if eventSent {
81t.Error("message was sent with disabled senderMode")
82}
83}()
84
85go func() {
86<-utils.SyncAddNewObject
87eventSent = true
88<-utils.SyncAddNewObject
89eventSent = true
90}()
91
92lib.ZapLogger = zap.NewNop()
93var storageController = &StorageController{}
94storageController.Start(false, tt.senderMode)
95storageController.UpdateTrigger(&tt.trigger)
96res, ok := storageController.triggers[tt.trigger.GetNamespacedName()]
97if !ok {
98t.Errorf("Trigger was not found")
99}
100if !reflect.DeepEqual(tt.trigger, res) {
101t.Errorf("Unexpected trigger value")
102}
103
104storageController.DeleteTrigger(&res)
105if _, ok := storageController.triggers[tt.trigger.GetNamespacedName()]; ok {
106t.Errorf("Trigger has not been deleted")
107}
108})
109}
110}
111
112func TestStorageController_UpdateTemplate(t *testing.T) {
113tests := []struct {
114name string
115message bell.Message
116template v1alpha1.Template
117senderMode bool
118}{
119{
120name: "ok",
121template: v1alpha1.Template{
122ObjectMeta: metav1.ObjectMeta{
123Name: "template",
124Namespace: "123",
125},
126},
127senderMode: true,
128},
129}
130for _, tt := range tests {
131t.Run(tt.name, func(t *testing.T) {
132var eventSent bool
133defer func() { eventSent = false }()
134defer func() {
135if tt.senderMode {
136time.Sleep(100 * time.Millisecond)
137if !eventSent {
138t.Error("message was not sent with enabled senderMode")
139}
140return
141}
142if eventSent {
143t.Error("message was sent with disabled senderMode")
144}
145}()
146
147go func() {
148<-utils.SyncAddNewObject
149eventSent = true
150<-utils.SyncAddNewObject
151eventSent = true
152}()
153
154lib.ZapLogger = zap.NewNop()
155var storageController = &StorageController{}
156storageController.Start(false, tt.senderMode)
157storageController.UpdateTemplate(&tt.template)
158res, ok := storageController.templates[tt.template.GetNamespacedName()]
159if !ok {
160t.Errorf("Template was not found")
161}
162if !reflect.DeepEqual(tt.template, res) {
163t.Errorf("Unexpected template value")
164}
165
166storageController.DeleteTemplate(&res)
167if _, ok := storageController.templates[tt.template.GetNamespacedName()]; ok {
168t.Errorf("Template has not been deleted")
169}
170})
171}
172}
173
174func TestStorageController_UpdateScope(t *testing.T) {
175tests := []struct {
176name string
177message bell.Message
178scope v1alpha1.Scope
179senderMode bool
180}{
181{
182name: "ok",
183scope: v1alpha1.Scope{
184ObjectMeta: metav1.ObjectMeta{
185Name: "scope",
186Namespace: "123",
187},
188},
189senderMode: true,
190},
191}
192for _, tt := range tests {
193t.Run(tt.name, func(t *testing.T) {
194var eventSent bool
195defer func() { eventSent = false }()
196defer func() {
197if tt.senderMode {
198time.Sleep(100 * time.Millisecond)
199if !eventSent {
200t.Error("message was not sent with enabled senderMode")
201}
202return
203}
204if eventSent {
205t.Error("message was sent with disabled senderMode")
206}
207}()
208
209go func() {
210<-utils.SyncAddNewObject
211eventSent = true
212<-utils.SyncAddNewObject
213eventSent = true
214}()
215
216lib.ZapLogger = zap.NewNop()
217var storageController = &StorageController{}
218storageController.Start(false, tt.senderMode)
219storageController.UpdateScope(tt.scope)
220res, ok := storageController.scopes[tt.scope.GetNamespacedName()]
221if !ok {
222t.Errorf("Scope was not found")
223}
224if !reflect.DeepEqual(tt.scope, res) {
225t.Errorf("Unexpected scope value")
226}
227
228storageController.GetScopeItems("")
229
230storageController.DeleteScope(tt.scope)
231if _, ok := storageController.scopes[tt.scope.GetNamespacedName()]; ok {
232t.Errorf("Scope has not been deleted")
233}
234})
235}
236}
237
238func TestStorageController_UpdateNamespace(t *testing.T) {
239tests := []struct {
240name string
241message bell.Message
242namespace corev1.Namespace
243senderMode bool
244}{
245{
246name: "ok",
247namespace: corev1.Namespace{
248ObjectMeta: metav1.ObjectMeta{
249Name: "namespace",
250Namespace: "123",
251},
252},
253senderMode: true,
254},
255}
256for _, tt := range tests {
257t.Run(tt.name, func(t *testing.T) {
258var eventSent bool
259defer func() { eventSent = false }()
260defer func() {
261if tt.senderMode {
262time.Sleep(100 * time.Millisecond)
263
264if !eventSent {
265t.Error("message was not sent with enabled senderMode")
266}
267return
268}
269if eventSent {
270t.Error("message was sent with disabled senderMode")
271}
272}()
273
274go func() {
275<-utils.SyncAddNewObject
276eventSent = true
277<-utils.SyncAddNewObject
278eventSent = true
279}()
280
281lib.ZapLogger = zap.NewNop()
282var storageController = &StorageController{}
283storageController.Start(false, tt.senderMode)
284storageController.UpdateNamespace(tt.namespace)
285res, ok := storageController.namespaces[tt.namespace.ObjectMeta.Name]
286if !ok {
287t.Errorf("Namespace was not found")
288}
289if !reflect.DeepEqual(tt.namespace, res) {
290t.Errorf("Unexpected namespace value")
291}
292
293storageController.DeleteNamespace(res)
294if _, ok := storageController.namespaces[tt.namespace.Namespace]; ok {
295t.Errorf("Namespace has not been deleted")
296}
297})
298}
299}
300
301func TestStorageController_GetResources(t *testing.T) {
302var storageController = &StorageController{}
303storageController.Start(false, false)
304storageController.GetScopes()
305storageController.GetTemplates()
306storageController.GetTriggers()
307storageController.GetNamespaces()
308storageController.GetScopeItems("validate")
309}
310
311func TestStorageController_CheckTriggerTemplatePair(t *testing.T) {
312tests := []struct {
313name string
314triggers map[string]v1alpha1.Trigger
315templates map[string]v1alpha1.Template
316}{
317{
318name: "ok",
319triggers: map[string]v1alpha1.Trigger{
320"triggerName": {Spec: v1alpha1.TriggerSpec{
321CreationConfigs: []v1alpha1.CreationConfig{
322{
323TemplateRefs: []string{"ref", "rrref"},
324},
325},
326}},
327},
328templates: map[string]v1alpha1.Template{"ref": {}},
329},
330}
331for _, tt := range tests {
332t.Run(tt.name, func(t *testing.T) {
333lib.ZapLogger = zap.NewNop()
334
335r := &StorageController{
336triggers: tt.triggers,
337templates: tt.templates,
338}
339r.CheckTriggerTemplatePair()
340})
341}
342}
343
344func TestStorageController_InitStorage(t *testing.T) {
345startKbltCreator := env.KbltCreator
346startKbltMutator := env.KbltMutator
347startKbltValidator := env.KbltValidator
348
349defer func() {
350env.KbltCreator = startKbltCreator
351env.KbltMutator = startKbltMutator
352env.KbltValidator = startKbltValidator
353}()
354
355env.KbltCreator = true
356env.KbltMutator = true
357env.KbltValidator = true
358
359lib.ZapLogger = zap.NewNop()
360
361restCli := mocks.NewInterface(t)
362restCli.On("Get", mock.Anything).Return(&rest.Request{}).Maybe()
363
364triggerCli := mocks.NewTriggerInterface(t)
365triggerCli.On("List", mock.Anything, mock.Anything).
366Return(&v1alpha1.TriggerList{Items: []v1alpha1.Trigger{{
367ObjectMeta: metav1.ObjectMeta{
368Name: "trig",
369Namespace: "123",
370}}}}, nil,
371).Maybe()
372
373templCli := mocks.NewTemplateInterface(t)
374templCli.On("List", mock.Anything, mock.Anything).
375Return(&v1alpha1.TemplateList{Items: []v1alpha1.Template{{
376ObjectMeta: metav1.ObjectMeta{
377Name: "templ",
378Namespace: "123"},
379}}}, nil).Maybe()
380
381scopeCli := mocks.NewScopeInterface(t)
382scopeCli.On("List", mock.Anything, mock.Anything).
383Return(&v1alpha1.ScopeList{Items: []v1alpha1.Scope{{
384ObjectMeta: metav1.ObjectMeta{
385Name: "scope",
386Namespace: "123"},
387}}}, nil).Maybe()
388
389triggerInsCli := mocks.NewTriggerInstanceInterface(t)
390
391utils.Cl = &clientset.V1Alpha1Client{
392TemplateClient: templCli,
393TriggerClient: triggerCli,
394ScopeClient: scopeCli,
395TriggerInstanceClient: triggerInsCli,
396RestClient: restCli,
397}
398
399r := &StorageController{}
400r.Start(true, false)
401r.Stop()
402utils.Cl = nil
403}
404
405func TestStorageController_DeleteRegoRule(t *testing.T) {
406r := &StorageController{
407regoRules: map[string]rego.PreparedEvalQuery{"name": {}},
408mutex: sync.Mutex{},
409}
410r.DeleteRegoRule("name")
411}
412
413func TestStorageController_UpdateRegoRule(t *testing.T) {
414r := &StorageController{
415regoRules: map[string]rego.PreparedEvalQuery{"name": {}},
416mutex: sync.Mutex{},
417}
418r.UpdateRegoRule("name", v1alpha1.TemplateSpec{Data: ""})
419}
420