1 package podman
2
3 import (
4 "os"
5 "reflect"
6 "testing"
7 "time"
8
9 corev1 "k8s.io/api/core/v1"
10 )
11
12 func TestPodmanCli_PodLs(t *testing.T) {
13 type fields struct {
14 podmanCmd string
15 podmanCmdInitTimeout time.Duration
16 containerRunGlobalExtraArgs []string
17 containerRunExtraArgs []string
18 }
19 tests := []struct {
20 name string
21 fields fields
22 populateFS func()
23 want map[string]bool
24 wantErr bool
25 }{
26 {
27 name: "command fails",
28 fields: fields{
29 podmanCmd: "false",
30 },
31 wantErr: true,
32 },
33 {
34 name: "command works, returns nothing",
35 fields: fields{
36 podmanCmd: "true",
37 },
38 wantErr: false,
39 want: map[string]bool{},
40 },
41 {
42 name: "command works, returns pods",
43 fields: fields{
44 podmanCmd: "./podman.fake.sh",
45 },
46 populateFS: func() {
47 script := []byte(`#!/bin/sh
48 case "$*" in
49 "pod list --format {{.Name}} --noheading")
50 echo name1
51 echo name2
52 echo name3
53 ;;
54 esac`)
55 err := os.WriteFile("podman.fake.sh", script, 0755)
56 if err != nil {
57 t.Fatal(err)
58 }
59 },
60 wantErr: false,
61 want: map[string]bool{
62 "name1": true,
63 "name2": true,
64 "name3": true,
65 },
66 },
67 }
68 for _, tt := range tests {
69 t.Run(tt.name, func(t *testing.T) {
70
71 if tt.populateFS != nil {
72 originWd, err := os.Getwd()
73 if err != nil {
74 t.Fatal(err)
75 }
76 defer func() {
77 _ = os.Chdir(originWd)
78 }()
79 cwd := t.TempDir()
80 err = os.Chdir(cwd)
81 if err != nil {
82 t.Fatal(err)
83 }
84 tt.populateFS()
85 }
86
87 o := &PodmanCli{
88 podmanCmd: tt.fields.podmanCmd,
89 podmanCmdInitTimeout: tt.fields.podmanCmdInitTimeout,
90 containerRunGlobalExtraArgs: tt.fields.containerRunGlobalExtraArgs,
91 containerRunExtraArgs: tt.fields.containerRunExtraArgs,
92 }
93 got, err := o.PodLs()
94 if (err != nil) != tt.wantErr {
95 t.Errorf("PodmanCli.PodLs() error = %v, wantErr %v", err, tt.wantErr)
96 return
97 }
98 if !reflect.DeepEqual(got, tt.want) {
99 t.Errorf("PodmanCli.PodLs() = %v, want %v", got, tt.want)
100 }
101 })
102 }
103 }
104
105 func TestPodmanCli_KubeGenerate(t *testing.T) {
106 type fields struct {
107 podmanCmd string
108 podmanCmdInitTimeout time.Duration
109 containerRunGlobalExtraArgs []string
110 containerRunExtraArgs []string
111 }
112 type args struct {
113 name string
114 }
115 tests := []struct {
116 name string
117 fields fields
118 populateFS func()
119 args args
120 checkResult func(*corev1.Pod)
121 wantErr bool
122 }{
123 {
124 name: "pod not found",
125 args: args{
126 name: "pod-not-found",
127 },
128 fields: fields{
129 podmanCmd: "./podman.fake.sh",
130 },
131 populateFS: func() {
132 script := []byte(`#!/bin/sh
133 case "$*" in
134 "generate kube pod-not-found")
135 exit 125
136 ;;
137 esac`)
138 err := os.WriteFile("podman.fake.sh", script, 0755)
139 if err != nil {
140 t.Fatal(err)
141 }
142 },
143 wantErr: true,
144 },
145 {
146 name: "command works, returns pod",
147 args: args{
148 name: "my-pod",
149 },
150 fields: fields{
151 podmanCmd: "./podman.fake.sh",
152 },
153 populateFS: func() {
154 script := []byte(`#!/bin/sh
155 case "$*" in
156 "generate kube my-pod")
157 cat <<EOF
158 apiVersion: v1
159 kind: Pod
160 metadata:
161 name: my-pod
162 EOF
163 ;;
164 esac`)
165 err := os.WriteFile("podman.fake.sh", script, 0755)
166 if err != nil {
167 t.Fatal(err)
168 }
169 },
170 wantErr: false,
171 checkResult: func(pod *corev1.Pod) {
172 podName := pod.GetName()
173 if podName != "my-pod" {
174 t.Errorf("pod name should be %q but is %q", "my-pod", podName)
175 }
176 },
177 },
178
179 }
180 for _, tt := range tests {
181 t.Run(tt.name, func(t *testing.T) {
182 if tt.populateFS != nil {
183 originWd, err := os.Getwd()
184 if err != nil {
185 t.Fatal(err)
186 }
187 defer func() {
188 _ = os.Chdir(originWd)
189 }()
190 cwd := t.TempDir()
191 err = os.Chdir(cwd)
192 if err != nil {
193 t.Fatal(err)
194 }
195 tt.populateFS()
196 }
197
198 o := &PodmanCli{
199 podmanCmd: tt.fields.podmanCmd,
200 podmanCmdInitTimeout: tt.fields.podmanCmdInitTimeout,
201 containerRunGlobalExtraArgs: tt.fields.containerRunGlobalExtraArgs,
202 containerRunExtraArgs: tt.fields.containerRunExtraArgs,
203 }
204 got, err := o.KubeGenerate(tt.args.name)
205 if (err != nil) != tt.wantErr {
206 t.Errorf("PodmanCli.KubeGenerate() error = %v, wantErr %v", err, tt.wantErr)
207 return
208 }
209
210 if tt.checkResult != nil {
211 tt.checkResult(got)
212 }
213 })
214 }
215 }
216
217 func TestPodmanCli_CleanupPodResources(t *testing.T) {
218 type fields struct {
219 podmanCmd string
220 podmanCmdInitTimeout time.Duration
221 containerRunGlobalExtraArgs []string
222 containerRunExtraArgs []string
223 }
224 type args struct {
225 pod func() *corev1.Pod
226 cleanupVolumes bool
227 }
228 tests := []struct {
229 name string
230 fields fields
231 args args
232 populateFS func()
233 wantErr bool
234 checkResult func()
235 }{
236 {
237 name: "cleanup pod, not volumes",
238 fields: fields{
239 podmanCmd: "./podman.fake.sh",
240 },
241 args: args{
242 pod: func() *corev1.Pod {
243 pod := corev1.Pod{}
244 pod.SetName("my-pod")
245 pod.Spec.Volumes = []corev1.Volume{
246 {
247 Name: "vol1",
248 VolumeSource: corev1.VolumeSource{
249 PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{
250 ClaimName: "volume1",
251 },
252 },
253 },
254 {
255 Name: "vol2",
256 VolumeSource: corev1.VolumeSource{
257 PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{
258 ClaimName: "volume2",
259 },
260 },
261 },
262 }
263 return &pod
264 },
265 cleanupVolumes: false,
266 },
267 populateFS: func() {
268 script := []byte(`#!/bin/sh
269 case "$*" in
270 "pod stop my-pod")
271 touch stop
272 echo my-pod
273 ;;
274 "pod rm my-pod")
275 touch rm
276 echo my-pod
277 ;;
278 "volume rm volume1")
279 touch volume1
280 ;;
281 "volume rm volume2")
282 touch volume2
283 ;;
284 esac`)
285 err := os.WriteFile("podman.fake.sh", script, 0755)
286 if err != nil {
287 t.Fatal(err)
288 }
289 },
290 checkResult: func() {
291 _, err := os.Stat("stop")
292 if err != nil {
293 t.Errorf("podman stop has not been called")
294 }
295 _, err = os.Stat("rm")
296 if err != nil {
297 t.Errorf("podman rm has not been called")
298 }
299 _, err = os.Stat("volume1")
300 if err == nil {
301 t.Errorf("podman rm volume volume1 has been called, it should not")
302 }
303 _, err = os.Stat("volume2")
304 if err == nil {
305 t.Errorf("podman rm volume volume2 has been called, it should not")
306 }
307 },
308 },
309 {
310 name: "cleanup pod and volumes",
311 fields: fields{
312 podmanCmd: "./podman.fake.sh",
313 },
314 args: args{
315 pod: func() *corev1.Pod {
316 pod := corev1.Pod{}
317 pod.SetName("my-pod")
318 pod.Spec.Volumes = []corev1.Volume{
319 {
320 Name: "vol1",
321 VolumeSource: corev1.VolumeSource{
322 PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{
323 ClaimName: "volume1",
324 },
325 },
326 },
327 {
328 Name: "vol2",
329 VolumeSource: corev1.VolumeSource{
330 PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{
331 ClaimName: "volume2",
332 },
333 },
334 },
335 }
336 return &pod
337 },
338 cleanupVolumes: true,
339 },
340 populateFS: func() {
341 script := []byte(`#!/bin/sh
342 case "$*" in
343 "pod stop my-pod")
344 touch stop
345 echo my-pod
346 ;;
347 "pod rm my-pod")
348 touch rm
349 echo my-pod
350 ;;
351 "volume rm volume1")
352 touch volume1
353 ;;
354 "volume rm volume2")
355 touch volume2
356 ;;
357 esac`)
358 err := os.WriteFile("podman.fake.sh", script, 0755)
359 if err != nil {
360 t.Fatal(err)
361 }
362 },
363 checkResult: func() {
364 _, err := os.Stat("stop")
365 if err != nil {
366 t.Errorf("podman stop has not been called")
367 }
368 _, err = os.Stat("rm")
369 if err != nil {
370 t.Errorf("podman rm has not been called")
371 }
372 _, err = os.Stat("volume1")
373 if err != nil {
374 t.Errorf("podman rm volume volume1 has not been called")
375 }
376 _, err = os.Stat("volume2")
377 if err != nil {
378 t.Errorf("podman rm volume volume2 has not been called")
379 }
380 },
381 },
382 }
383 for _, tt := range tests {
384 t.Run(tt.name, func(t *testing.T) {
385 if tt.populateFS != nil {
386 originWd, err := os.Getwd()
387 if err != nil {
388 t.Fatal(err)
389 }
390 defer func() {
391 _ = os.Chdir(originWd)
392 }()
393 cwd := t.TempDir()
394 err = os.Chdir(cwd)
395 if err != nil {
396 t.Fatal(err)
397 }
398 tt.populateFS()
399 }
400
401 o := &PodmanCli{
402 podmanCmd: tt.fields.podmanCmd,
403 podmanCmdInitTimeout: tt.fields.podmanCmdInitTimeout,
404 containerRunGlobalExtraArgs: tt.fields.containerRunGlobalExtraArgs,
405 containerRunExtraArgs: tt.fields.containerRunExtraArgs,
406 }
407 if err := o.CleanupPodResources(tt.args.pod(), tt.args.cleanupVolumes); (err != nil) != tt.wantErr {
408 t.Errorf("PodmanCli.CleanupPodResources() error = %v, wantErr %v", err, tt.wantErr)
409 }
410
411 if tt.checkResult != nil {
412 tt.checkResult()
413 }
414 })
415 }
416 }
417
View as plain text