1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package inject
17
18 import (
19 . "github.com/onsi/ginkgo"
20 . "github.com/onsi/gomega"
21 admissionv1 "k8s.io/api/admission/v1"
22 corev1 "k8s.io/api/core/v1"
23 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
24 "sigs.k8s.io/controller-runtime/pkg/client"
25
26 controllerCfg "github.com/chaos-mesh/chaos-mesh/pkg/config"
27 "github.com/chaos-mesh/chaos-mesh/pkg/webhook/config"
28 )
29
30 var _ = Describe("webhook inject", func() {
31
32 Context("Inject", func() {
33 It("should return unexpected end of JSON input", func() {
34 var testClient client.Client
35 var cfg *config.Config
36 var controllerCfg *controllerCfg.ChaosControllerConfig
37 res := Inject(&admissionv1.AdmissionRequest{}, testClient, cfg, controllerCfg, nil)
38 Expect(res.Result.Message).To(ContainSubstring("unexpected end of JSON input"))
39 })
40 })
41
42 Context("checkInjectStatus", func() {
43 It("should return false", func() {
44 var metadata metav1.ObjectMeta
45 metadata.Annotations = make(map[string]string)
46 var cfg config.Config
47 res := checkInjectStatus(&metadata, &cfg)
48 Expect(res).To(Equal(false))
49 })
50
51 It("should return true", func() {
52 var metadata metav1.ObjectMeta
53 metadata.Annotations = make(map[string]string)
54 metadata.Annotations["testNamespace/status"] = StatusInjected
55 var cfg config.Config
56 cfg.AnnotationNamespace = "testNamespace"
57 res := checkInjectStatus(&metadata, &cfg)
58 Expect(res).To(Equal(true))
59 })
60 })
61
62 Context("injectByPodRequired", func() {
63 It("should return false", func() {
64 var metadata metav1.ObjectMeta
65 metadata.Annotations = make(map[string]string)
66 var cfg config.Config
67 str, flag := injectByPodRequired(&metadata, &cfg)
68 Expect(str).To(Equal(""))
69 Expect(flag).To(Equal(false))
70 })
71
72 It("should return false", func() {
73 var metadata metav1.ObjectMeta
74 metadata.Annotations = make(map[string]string)
75 metadata.Annotations["testNamespace/request"] = "test"
76 var cfg config.Config
77 cfg.AnnotationNamespace = "testNamespace"
78 str, flag := injectByPodRequired(&metadata, &cfg)
79 Expect(str).To(Equal("test"))
80 Expect(flag).To(Equal(true))
81 })
82 })
83
84 Context("injectRequired", func() {
85 It("should return ignore", func() {
86 var metadata metav1.ObjectMeta
87 metadata.Annotations = make(map[string]string)
88 metadata.Namespace = "kube-system"
89 var cli client.Client
90 var cfg config.Config
91 var controllerCfg controllerCfg.ChaosControllerConfig
92 str, flag := injectRequired(&metadata, cli, &cfg, &controllerCfg)
93 Expect(str).To(Equal(""))
94 Expect(flag).To(Equal(false))
95 })
96
97 It("should return ignore", func() {
98 var metadata metav1.ObjectMeta
99 metadata.Annotations = make(map[string]string)
100 metadata.Annotations["testNamespace/status"] = StatusInjected
101 var cfg config.Config
102 var controllerCfg controllerCfg.ChaosControllerConfig
103 cfg.AnnotationNamespace = "testNamespace"
104 var cli client.Client
105 str, flag := injectRequired(&metadata, cli, &cfg, &controllerCfg)
106 Expect(str).To(Equal(""))
107 Expect(flag).To(Equal(false))
108 })
109
110 It("should return ignore", func() {
111 var metadata metav1.ObjectMeta
112 metadata.Annotations = make(map[string]string)
113 metadata.Annotations["testNamespace/status"] = StatusInjected
114 var cfg config.Config
115 var controllerCfg controllerCfg.ChaosControllerConfig
116 cfg.AnnotationNamespace = "testNamespace"
117 var cli client.Client
118 str, flag := injectRequired(&metadata, cli, &cfg, &controllerCfg)
119 Expect(str).To(Equal(""))
120 Expect(flag).To(Equal(false))
121 })
122
123 It("should return Pod annotation requesting sidecar config", func() {
124 var metadata metav1.ObjectMeta
125 metadata.Annotations = make(map[string]string)
126 metadata.Annotations["testNamespace/request"] = "test"
127 metadata.Namespace = "testNamespace"
128 var cfg config.Config
129 var controllerCfg controllerCfg.ChaosControllerConfig
130 cfg.AnnotationNamespace = "testNamespace"
131 str, flag := injectRequired(&metadata, k8sClient, &cfg, &controllerCfg)
132 Expect(str).To(Equal("test"))
133 Expect(flag).To(Equal(true))
134 })
135
136 It("should return false", func() {
137 var metadata metav1.ObjectMeta
138 metadata.Annotations = make(map[string]string)
139 var cfg config.Config
140 var controllerCfg controllerCfg.ChaosControllerConfig
141 _, flag := injectRequired(&metadata, k8sClient, &cfg, &controllerCfg)
142 Expect(flag).To(Equal(false))
143 })
144 })
145
146 Context("injectByNamespaceRequired", func() {
147 It("should return nil and false", func() {
148 var metadata metav1.ObjectMeta
149 metadata.Annotations = make(map[string]string)
150 metadata.Namespace = "testNamespace"
151 var cfg config.Config
152 str, flag := injectByNamespaceRequired(&metadata, k8sClient, &cfg)
153 Expect(str).To(Equal(""))
154 Expect(flag).To(Equal(false))
155 })
156 })
157
158 Context("createPatch", func() {
159 It("should return nil and false", func() {
160 var pod corev1.Pod
161 var inj config.InjectionConfig
162 annotations := make(map[string]string)
163 _, err := createPatch(&pod, &inj, annotations)
164 Expect(err).To(BeNil())
165 })
166 })
167
168 Context("setCommands", func() {
169 It("should return", func() {
170 var target []corev1.Container = []corev1.Container{
171 {
172 Name: "testContainerName",
173 }}
174 postStart := make(map[string]config.ExecAction)
175 patch := setCommands(target, postStart)
176 Expect(patch).To(BeNil())
177 })
178
179 It("should return nil", func() {
180 var target []corev1.Container = []corev1.Container{
181 {
182 Name: "testContainerName",
183 }}
184 postStart := make(map[string]config.ExecAction)
185 var ce config.ExecAction = config.ExecAction{
186 Command: []string{"nil"},
187 }
188 postStart["testContainerName"] = ce
189 patch := setCommands(target, postStart)
190 Expect(patch).ToNot(BeNil())
191 })
192 })
193
194 Context("setEnvironment", func() {
195 It("should return not nil", func() {
196 var target []corev1.Container = []corev1.Container{
197 {
198 Name: "testContainerName",
199 }}
200 var addEnv []corev1.EnvVar = []corev1.EnvVar{
201 {
202 Name: "testContainerName",
203 }}
204 patch := setEnvironment(target, addEnv)
205 Expect(patch).ToNot(BeNil())
206 })
207
208 It("should return not nil", func() {
209 var Env []corev1.EnvVar = []corev1.EnvVar{
210 {
211 Name: "_testContainerName_",
212 }}
213 var target []corev1.Container = []corev1.Container{
214 {
215 Name: "testContainerName",
216 Env: Env,
217 }}
218 var addEnv []corev1.EnvVar = []corev1.EnvVar{
219 {
220 Name: "testContainerName",
221 }}
222 patch := setEnvironment(target, addEnv)
223 Expect(patch).ToNot(BeNil())
224 })
225
226 It("should return nil", func() {
227 var Env []corev1.EnvVar = []corev1.EnvVar{
228 {
229 Name: "testContainerName",
230 }}
231 var target []corev1.Container = []corev1.Container{
232 {
233 Name: "testContainerName",
234 Env: Env,
235 }}
236 var addEnv []corev1.EnvVar = []corev1.EnvVar{
237 {
238 Name: "testContainerName",
239 }}
240 patch := setEnvironment(target, addEnv)
241 Expect(patch).To(BeNil())
242 })
243 })
244
245 Context("addContainers", func() {
246 It("should return not nil", func() {
247 var target []corev1.Container = []corev1.Container{
248 {
249 Name: "testContainerName",
250 }}
251 var added []corev1.Container = []corev1.Container{
252 {
253 Name: "testContainerName",
254 }}
255 basePath := "/test"
256 patch := addContainers(target, added, basePath)
257 Expect(patch).ToNot(BeNil())
258 })
259
260 It("should return not nil", func() {
261 var target []corev1.Container = []corev1.Container{}
262 var added []corev1.Container = []corev1.Container{
263 {
264 Name: "testContainerName",
265 }}
266 basePath := "/test"
267 patch := addContainers(target, added, basePath)
268 Expect(patch).ToNot(BeNil())
269 })
270 })
271
272 Context("addVolumes", func() {
273 It("should return not nil", func() {
274 var target []corev1.Volume = []corev1.Volume{
275 {
276 Name: "test",
277 }}
278 var added []corev1.Volume = []corev1.Volume{
279 {
280 Name: "test",
281 }}
282 basePath := "/test"
283 patch := addVolumes(target, added, basePath)
284 Expect(patch).ToNot(BeNil())
285 })
286
287 It("should return not nil", func() {
288 var target []corev1.Volume = []corev1.Volume{}
289 var added []corev1.Volume = []corev1.Volume{
290 {
291 Name: "test",
292 }}
293 basePath := "/test"
294 patch := addVolumes(target, added, basePath)
295 Expect(patch).ToNot(BeNil())
296 })
297 })
298
299 Context("setVolumeMounts", func() {
300 It("should return not nil", func() {
301 var vm []corev1.VolumeMount = []corev1.VolumeMount{
302 {
303 Name: "test",
304 }}
305 var target []corev1.Container = []corev1.Container{
306 {
307 Name: "test",
308 VolumeMounts: vm,
309 }}
310 var added []corev1.VolumeMount = []corev1.VolumeMount{
311 {
312 Name: "test",
313 }}
314 basePath := "/test"
315 patch := setVolumeMounts(target, added, basePath)
316 Expect(patch).ToNot(BeNil())
317 })
318 })
319
320 Context("addHostAliases", func() {
321 It("should return not nil", func() {
322 var target []corev1.HostAlias = []corev1.HostAlias{
323 {
324 IP: "testip",
325 }}
326 var added []corev1.HostAlias = []corev1.HostAlias{
327 {
328 IP: "testip",
329 }}
330 basePath := "/test"
331 patch := addHostAliases(target, added, basePath)
332 Expect(patch).ToNot(BeNil())
333 })
334
335 It("should return not nil", func() {
336 var target []corev1.HostAlias = []corev1.HostAlias{}
337 var added []corev1.HostAlias = []corev1.HostAlias{
338 {
339 IP: "testip",
340 }}
341 basePath := "/test"
342 patch := addHostAliases(target, added, basePath)
343 Expect(patch).ToNot(BeNil())
344 })
345 })
346
347 Context("mergeEnvVars", func() {
348 It("should return not nil", func() {
349 var envs []corev1.EnvVar = []corev1.EnvVar{
350 {
351 Name: "test",
352 }}
353 var containers []corev1.Container = []corev1.Container{
354 {
355 Name: "test",
356 }}
357 mutatedContainers := mergeEnvVars(envs, containers)
358 Expect(mutatedContainers).ToNot(BeNil())
359 })
360
361 It("should return not nil", func() {
362 var envs []corev1.EnvVar = []corev1.EnvVar{
363 {
364 Name: "test",
365 }}
366 var env []corev1.EnvVar = []corev1.EnvVar{
367 {
368 Name: "test",
369 }}
370 var containers []corev1.Container = []corev1.Container{
371 {
372 Name: "test",
373 Env: env,
374 }}
375 mutatedContainers := mergeEnvVars(envs, containers)
376 Expect(mutatedContainers).ToNot(BeNil())
377 })
378 })
379
380 Context("mergeVolumeMounts", func() {
381 It("should return not nil", func() {
382 var volumeMounts []corev1.VolumeMount = []corev1.VolumeMount{
383 {
384 Name: "test",
385 }}
386 var containers []corev1.Container = []corev1.Container{
387 {
388 Name: "test",
389 }}
390 mutatedContainers := mergeVolumeMounts(volumeMounts, containers)
391 Expect(mutatedContainers).ToNot(BeNil())
392 })
393
394 It("should return not nil", func() {
395 var volumeMounts []corev1.VolumeMount = []corev1.VolumeMount{
396 {
397 Name: "test",
398 }}
399 var vm []corev1.VolumeMount = []corev1.VolumeMount{
400 {
401 Name: "test",
402 }}
403 var containers []corev1.Container = []corev1.Container{
404 {
405 Name: "test",
406 VolumeMounts: vm,
407 }}
408 mutatedContainers := mergeVolumeMounts(volumeMounts, containers)
409 Expect(mutatedContainers).ToNot(BeNil())
410 })
411 })
412
413 Context("updateAnnotations", func() {
414 It("should return not nil", func() {
415 target := make(map[string]string)
416 added := make(map[string]string)
417 added["testKey"] = "testValue"
418 patch := updateAnnotations(target, added)
419 Expect(patch).ToNot(BeNil())
420 })
421
422 It("should return not nil", func() {
423 target := make(map[string]string)
424 added := make(map[string]string)
425 added["testKey"] = "testValue"
426 target["testKey"] = "testValue"
427 patch := updateAnnotations(target, added)
428 Expect(patch).ToNot(BeNil())
429 })
430 })
431
432 Context("potentialPodName", func() {
433 It("should return testName", func() {
434 var metadata metav1.ObjectMeta
435 metadata.Name = "testName"
436 name := potentialPodName(&metadata)
437 Expect(name).ToNot(BeNil())
438 Expect(name).To(Equal("testName"))
439 })
440
441 It("should return (actual name not yet known)", func() {
442 var metadata metav1.ObjectMeta
443 metadata.GenerateName = "testName"
444 name := potentialPodName(&metadata)
445 Expect(name).ToNot(BeNil())
446 Expect(name).To(ContainSubstring("(actual name not yet known)"))
447 })
448
449 It("should return nil", func() {
450 var metadata metav1.ObjectMeta
451 name := potentialPodName(&metadata)
452 Expect(name).To(Equal(""))
453 })
454 })
455 })
456