1/*
2Copyright 2016 The Kubernetes Authors.
3
4Licensed under the Apache License, Version 2.0 (the "License");
5you may not use this file except in compliance with the License.
6You may obtain a copy of the License at
7
8    http://www.apache.org/licenses/LICENSE-2.0
9
10Unless required by applicable law or agreed to in writing, software
11distributed under the License is distributed on an "AS IS" BASIS,
12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13See the License for the specific language governing permissions and
14limitations under the License.
15*/
16
17package cache
18
19import (
20	"testing"
21
22	"k8s.io/api/core/v1"
23	k8stypes "k8s.io/apimachinery/pkg/types"
24	controllervolumetesting "k8s.io/kubernetes/pkg/controller/volume/attachdetach/testing"
25	volumetesting "k8s.io/kubernetes/pkg/volume/testing"
26	"k8s.io/kubernetes/pkg/volume/util/types"
27)
28
29// Calls AddNode() once.
30// Verifies node exists, and zero volumes to attach.
31func Test_AddNode_Positive_NewNode(t *testing.T) {
32	// Arrange
33	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
34	dsw := NewDesiredStateOfWorld(volumePluginMgr)
35	nodeName := k8stypes.NodeName("node-name")
36
37	// Act
38	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
39
40	// Assert
41	nodeExists := dsw.NodeExists(nodeName)
42	if !nodeExists {
43		t.Fatalf("Added node %q does not exist, it should.", nodeName)
44	}
45
46	volumesToAttach := dsw.GetVolumesToAttach()
47	if len(volumesToAttach) != 0 {
48		t.Fatalf("len(volumesToAttach) Expected: <0> Actual: <%v>", len(volumesToAttach))
49	}
50}
51
52// Calls AddNode() once.
53// Verifies node exists.
54// Calls AddNode() again with the same node.
55// Verifies node exists, and zero volumes to attach.
56func Test_AddNode_Positive_ExistingNode(t *testing.T) {
57	// Arrange
58	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
59	dsw := NewDesiredStateOfWorld(volumePluginMgr)
60	nodeName := k8stypes.NodeName("node-name")
61
62	// Act
63	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
64
65	// Assert
66	nodeExists := dsw.NodeExists(nodeName)
67	if !nodeExists {
68		t.Fatalf("Added node %q does not exist, it should.", nodeName)
69	}
70
71	// Act
72	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
73
74	// Assert
75	nodeExists = dsw.NodeExists(nodeName)
76	if !nodeExists {
77		t.Fatalf("Added node %q does not exist, it should.", nodeName)
78	}
79
80	volumesToAttach := dsw.GetVolumesToAttach()
81	if len(volumesToAttach) != 0 {
82		t.Fatalf("len(volumesToAttach) Expected: <0> Actual: <%v>", len(volumesToAttach))
83	}
84}
85
86// Populates data struct with a single node no volume.
87// Calls AddPod() with the same node and new pod/volume.
88// Verifies node/volume exists, and 1 volumes to attach.
89func Test_AddPod_Positive_NewPodNodeExistsVolumeDoesntExist(t *testing.T) {
90	// Arrange
91	podName := "pod-uid"
92	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
93	dsw := NewDesiredStateOfWorld(volumePluginMgr)
94	volumeName := v1.UniqueVolumeName("volume-name")
95	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
96	nodeName := k8stypes.NodeName("node-name")
97	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
98	volumeExists := dsw.VolumeExists(volumeName, nodeName)
99	if volumeExists {
100		t.Fatalf(
101			"Volume %q/node %q should not exist, but it does.",
102			volumeName,
103			nodeName)
104	}
105
106	// Act
107	generatedVolumeName, podErr := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)
108
109	// Assert
110	if podErr != nil {
111		t.Fatalf("AddPod failed. Expected: <no error> Actual: <%v>", podErr)
112	}
113
114	volumeExists = dsw.VolumeExists(generatedVolumeName, nodeName)
115	if !volumeExists {
116		t.Fatalf(
117			"Added pod %q to volume %q/node %q. Volume does not exist, it should.",
118			podName,
119			generatedVolumeName,
120			nodeName)
121	}
122
123	volumesToAttach := dsw.GetVolumesToAttach()
124	if len(volumesToAttach) != 1 {
125		t.Fatalf("len(volumesToAttach) Expected: <1> Actual: <%v>", len(volumesToAttach))
126	}
127
128	verifyVolumeToAttach(t, volumesToAttach, nodeName, generatedVolumeName, string(volumeName))
129}
130
131// Populates data struct with a single node no volume.
132// Calls AddPod() with the same node and new pod/volume.
133// Verifies node/volume exists.
134// Calls AddPod() with the same node and volume different pod.
135// Verifies the same node/volume exists, and 1 volumes to attach.
136func Test_AddPod_Positive_NewPodNodeExistsVolumeExists(t *testing.T) {
137	// Arrange
138	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
139	dsw := NewDesiredStateOfWorld(volumePluginMgr)
140	pod1Name := "pod1-uid"
141	pod2Name := "pod2-uid"
142	volumeName := v1.UniqueVolumeName("volume-name")
143	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
144	nodeName := k8stypes.NodeName("node-name")
145	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
146	volumeExists := dsw.VolumeExists(volumeName, nodeName)
147	if volumeExists {
148		t.Fatalf(
149			"Volume %q/node %q should not exist, but it does.",
150			volumeName,
151			nodeName)
152	}
153
154	// Act
155	generatedVolumeName, podErr := dsw.AddPod(types.UniquePodName(pod1Name), controllervolumetesting.NewPod(pod1Name, pod1Name), volumeSpec, nodeName)
156
157	// Assert
158	if podErr != nil {
159		t.Fatalf(
160			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
161			pod1Name,
162			podErr)
163	}
164
165	volumeExists = dsw.VolumeExists(generatedVolumeName, nodeName)
166	if !volumeExists {
167		t.Fatalf(
168			"Added pod %q to volume %q/node %q. Volume does not exist, it should.",
169			pod1Name,
170			generatedVolumeName,
171			nodeName)
172	}
173
174	// Act
175	generatedVolumeName, podErr = dsw.AddPod(types.UniquePodName(pod2Name), controllervolumetesting.NewPod(pod2Name, pod2Name), volumeSpec, nodeName)
176
177	// Assert
178	if podErr != nil {
179		t.Fatalf("AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
180			pod2Name,
181			podErr)
182	}
183
184	volumeExists = dsw.VolumeExists(generatedVolumeName, nodeName)
185	if !volumeExists {
186		t.Fatalf(
187			"Added pod %q to volume %q/node %q. Volume does not exist, it should.",
188			pod1Name,
189			generatedVolumeName,
190			nodeName)
191	}
192
193	volumesToAttach := dsw.GetVolumesToAttach()
194	if len(volumesToAttach) != 1 {
195		t.Fatalf("len(volumesToAttach) Expected: <1> Actual: <%v>", len(volumesToAttach))
196	}
197
198	podScheduled := dsw.GetPodToAdd()
199	if len(podScheduled) != 2 {
200		t.Fatalf("len(podScheduled) Expected: <2> Actual: <%v>", len(podScheduled))
201	}
202	verifyVolumeToAttach(t, volumesToAttach, nodeName, generatedVolumeName, string(volumeName))
203}
204
205// Populates data struct with a single node no volume.
206// Calls AddPod() with the same node and new pod/volume.
207// Verifies node/volume exists.
208// Calls AddPod() with the same node, volume, and pod.
209// Verifies the same node/volume exists, and 1 volumes to attach.
210func Test_AddPod_Positive_PodExistsNodeExistsVolumeExists(t *testing.T) {
211	// Arrange
212	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
213	dsw := NewDesiredStateOfWorld(volumePluginMgr)
214	podName := "pod-uid"
215	volumeName := v1.UniqueVolumeName("volume-name")
216	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
217	nodeName := k8stypes.NodeName("node-name")
218	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
219	volumeExists := dsw.VolumeExists(volumeName, nodeName)
220	if volumeExists {
221		t.Fatalf(
222			"Volume %q/node %q should not exist, but it does.",
223			volumeName,
224			nodeName)
225	}
226
227	// Act
228	generatedVolumeName, podErr := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)
229
230	// Assert
231	if podErr != nil {
232		t.Fatalf(
233			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
234			podName,
235			podErr)
236	}
237
238	volumeExists = dsw.VolumeExists(generatedVolumeName, nodeName)
239	if !volumeExists {
240		t.Fatalf(
241			"Added pod %q to volume %q/node %q. Volume does not exist, it should.",
242			podName,
243			generatedVolumeName,
244			nodeName)
245	}
246
247	// Act
248	generatedVolumeName, podErr = dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)
249
250	// Assert
251	if podErr != nil {
252		t.Fatalf("AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
253			podName,
254			podErr)
255	}
256
257	volumeExists = dsw.VolumeExists(generatedVolumeName, nodeName)
258	if !volumeExists {
259		t.Fatalf(
260			"Added pod %q to volume %q/node %q. Volume does not exist, it should.",
261			podName,
262			generatedVolumeName,
263			nodeName)
264	}
265
266	volumesToAttach := dsw.GetVolumesToAttach()
267	if len(volumesToAttach) != 1 {
268		t.Fatalf("len(volumesToAttach) Expected: <1> Actual: <%v>", len(volumesToAttach))
269	}
270
271	verifyVolumeToAttach(t, volumesToAttach, nodeName, generatedVolumeName, string(volumeName))
272}
273
274// Calls AddPod() with new pod/volume/node on empty data struct.
275// Verifies call fails because node does not exist.
276func Test_AddPod_Negative_NewPodNodeDoesntExistVolumeDoesntExist(t *testing.T) {
277	// Arrange
278	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
279	dsw := NewDesiredStateOfWorld(volumePluginMgr)
280	podName := "pod-uid"
281	volumeName := v1.UniqueVolumeName("volume-name")
282	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
283	nodeName := k8stypes.NodeName("node-name")
284	volumeExists := dsw.VolumeExists(volumeName, nodeName)
285	if volumeExists {
286		t.Fatalf(
287			"Volume %q/node %q should not exist, but it does.",
288			volumeName,
289			nodeName)
290	}
291
292	// Act
293	_, podErr := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)
294
295	// Assert
296	if podErr == nil {
297		t.Fatalf("AddPod did not fail. Expected: <\"failed to add pod...no node with that name exists in the list of managed nodes\"> Actual: <no error>")
298	}
299
300	volumeExists = dsw.VolumeExists(volumeName, nodeName)
301	if volumeExists {
302		t.Fatalf(
303			"Volume %q/node %q should not exist, but it does.",
304			volumeName,
305			nodeName)
306	}
307
308	volumesToAttach := dsw.GetVolumesToAttach()
309	if len(volumesToAttach) != 0 {
310		t.Fatalf("len(volumesToAttach) Expected: <0> Actual: <%v>", len(volumesToAttach))
311	}
312}
313
314// Populates data struct with a single node.
315// Calls DeleteNode() to delete the node.
316// Verifies node no longer exists, and zero volumes to attach.
317func Test_DeleteNode_Positive_NodeExists(t *testing.T) {
318	// Arrange
319	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
320	dsw := NewDesiredStateOfWorld(volumePluginMgr)
321	nodeName := k8stypes.NodeName("node-name")
322	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
323
324	// Act
325	err := dsw.DeleteNode(nodeName)
326
327	// Assert
328	if err != nil {
329		t.Fatalf("DeleteNode failed. Expected: <no error> Actual: <%v>", err)
330	}
331
332	nodeExists := dsw.NodeExists(nodeName)
333	if nodeExists {
334		t.Fatalf("Deleted node %q still exists, it should not.", nodeName)
335	}
336
337	volumesToAttach := dsw.GetVolumesToAttach()
338	if len(volumesToAttach) != 0 {
339		t.Fatalf("len(volumesToAttach) Expected: <0> Actual: <%v>", len(volumesToAttach))
340	}
341}
342
343// Calls DeleteNode() to delete node on empty data struct.
344// Verifies no error is returned, and zero volumes to attach.
345func Test_DeleteNode_Positive_NodeDoesntExist(t *testing.T) {
346	// Arrange
347	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
348	dsw := NewDesiredStateOfWorld(volumePluginMgr)
349	notAddedNodeName := k8stypes.NodeName("node-not-added-name")
350
351	// Act
352	err := dsw.DeleteNode(notAddedNodeName)
353
354	// Assert
355	if err != nil {
356		t.Fatalf("DeleteNode failed. Expected: <no error> Actual: <%v>", err)
357	}
358
359	nodeExists := dsw.NodeExists(notAddedNodeName)
360	if nodeExists {
361		t.Fatalf("Deleted node %q still exists, it should not.", notAddedNodeName)
362	}
363
364	volumesToAttach := dsw.GetVolumesToAttach()
365	if len(volumesToAttach) != 0 {
366		t.Fatalf("len(volumesToAttach) Expected: <0> Actual: <%v>", len(volumesToAttach))
367	}
368}
369
370// Populates data struct with new pod/volume/node.
371// Calls DeleteNode() to delete the node.
372// Verifies call fails because node still contains child volumes.
373func Test_DeleteNode_Negative_NodeExistsHasChildVolumes(t *testing.T) {
374	// Arrange
375	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
376	dsw := NewDesiredStateOfWorld(volumePluginMgr)
377	nodeName := k8stypes.NodeName("node-name")
378	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
379	podName := "pod-uid"
380	volumeName := v1.UniqueVolumeName("volume-name")
381	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
382	generatedVolumeName, podAddErr := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)
383	if podAddErr != nil {
384		t.Fatalf(
385			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
386			podName,
387			podAddErr)
388	}
389
390	// Act
391	err := dsw.DeleteNode(nodeName)
392
393	// Assert
394	if err == nil {
395		t.Fatalf("DeleteNode did not fail. Expected: <\"failed to delete node...the node still contains volumes in its list of volumes to attach\"> Actual: <no error>")
396	}
397
398	nodeExists := dsw.NodeExists(nodeName)
399	if !nodeExists {
400		t.Fatalf("Node %q no longer exists, it should.", nodeName)
401	}
402
403	volumesToAttach := dsw.GetVolumesToAttach()
404	if len(volumesToAttach) != 1 {
405		t.Fatalf("len(volumesToAttach) Expected: <1> Actual: <%v>", len(volumesToAttach))
406	}
407
408	verifyVolumeToAttach(t, volumesToAttach, nodeName, generatedVolumeName, string(volumeName))
409}
410
411// Populates data struct with new pod/volume/node.
412// Calls DeleteNode() to delete the pod/volume/node.
413// Verifies volume no longer exists, and zero volumes to attach.
414func Test_DeletePod_Positive_PodExistsNodeExistsVolumeExists(t *testing.T) {
415	// Arrange
416	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
417	dsw := NewDesiredStateOfWorld(volumePluginMgr)
418	podName := "pod-uid"
419	volumeName := v1.UniqueVolumeName("volume-name")
420	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
421	nodeName := k8stypes.NodeName("node-name")
422	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
423	generatedVolumeName, podAddErr := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)
424	if podAddErr != nil {
425		t.Fatalf(
426			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
427			podName,
428			podAddErr)
429	}
430	volumeExists := dsw.VolumeExists(generatedVolumeName, nodeName)
431	if !volumeExists {
432		t.Fatalf(
433			"Added pod %q to volume %q/node %q. Volume does not exist, it should.",
434			podName,
435			generatedVolumeName,
436			nodeName)
437	}
438
439	// Act
440	dsw.DeletePod(types.UniquePodName(podName), generatedVolumeName, nodeName)
441
442	// Assert
443	volumeExists = dsw.VolumeExists(generatedVolumeName, nodeName)
444	if volumeExists {
445		t.Fatalf(
446			"Deleted pod %q from volume %q/node %q. Volume should also be deleted but it still exists.",
447			podName,
448			generatedVolumeName,
449			nodeName)
450	}
451
452	volumesToAttach := dsw.GetVolumesToAttach()
453	if len(volumesToAttach) != 0 {
454		t.Fatalf("len(volumesToAttach) Expected: <0> Actual: <%v>", len(volumesToAttach))
455	}
456}
457
458// Populates data struct with pod1/volume/node and pod2/volume/node.
459// Calls DeleteNode() to delete the pod1/volume/node.
460// Verifies volume still exists, and one volumes to attach.
461func Test_DeletePod_Positive_2PodsExistNodeExistsVolumesExist(t *testing.T) {
462	// Arrange
463	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
464	dsw := NewDesiredStateOfWorld(volumePluginMgr)
465	pod1Name := "pod1-uid"
466	pod2Name := "pod2-uid"
467	volumeName := v1.UniqueVolumeName("volume-name")
468	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
469	nodeName := k8stypes.NodeName("node-name")
470	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
471	generatedVolumeName1, pod1AddErr := dsw.AddPod(types.UniquePodName(pod1Name), controllervolumetesting.NewPod(pod1Name, pod1Name), volumeSpec, nodeName)
472	if pod1AddErr != nil {
473		t.Fatalf(
474			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
475			pod1Name,
476			pod1AddErr)
477	}
478	generatedVolumeName2, pod2AddErr := dsw.AddPod(types.UniquePodName(pod2Name), controllervolumetesting.NewPod(pod2Name, pod2Name), volumeSpec, nodeName)
479	if pod2AddErr != nil {
480		t.Fatalf(
481			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
482			pod2Name,
483			pod2AddErr)
484	}
485	if generatedVolumeName1 != generatedVolumeName2 {
486		t.Fatalf(
487			"Generated volume names for the same volume should be the same but they are not: %q and %q",
488			generatedVolumeName1,
489			generatedVolumeName2)
490	}
491	volumeExists := dsw.VolumeExists(generatedVolumeName1, nodeName)
492	if !volumeExists {
493		t.Fatalf(
494			"Volume %q does not exist under node %q, it should.",
495			generatedVolumeName1,
496			nodeName)
497	}
498
499	// Act
500	dsw.DeletePod(types.UniquePodName(pod1Name), generatedVolumeName1, nodeName)
501
502	// Assert
503	volumeExists = dsw.VolumeExists(generatedVolumeName1, nodeName)
504	if !volumeExists {
505		t.Fatalf(
506			"Volume %q under node %q should still exist, but it does not.",
507			generatedVolumeName1,
508			nodeName)
509	}
510
511	volumesToAttach := dsw.GetVolumesToAttach()
512	if len(volumesToAttach) != 1 {
513		t.Fatalf("len(volumesToAttach) Expected: <1> Actual: <%v>", len(volumesToAttach))
514	}
515
516	verifyVolumeToAttach(t, volumesToAttach, nodeName, generatedVolumeName1, string(volumeName))
517}
518
519// Populates data struct with pod1/volume/node.
520// Calls DeleteNode() to delete the pod2/volume/node.
521// Verifies volume still exists, and one volumes to attach.
522func Test_DeletePod_Positive_PodDoesNotExist(t *testing.T) {
523	// Arrange
524	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
525	dsw := NewDesiredStateOfWorld(volumePluginMgr)
526	pod1Name := "pod1-uid"
527	pod2Name := "pod2-uid"
528	volumeName := v1.UniqueVolumeName("volume-name")
529	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
530	nodeName := k8stypes.NodeName("node-name")
531	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
532	generatedVolumeName, pod1AddErr := dsw.AddPod(types.UniquePodName(pod1Name), controllervolumetesting.NewPod(pod1Name, pod1Name), volumeSpec, nodeName)
533	if pod1AddErr != nil {
534		t.Fatalf(
535			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
536			pod1Name,
537			pod1AddErr)
538	}
539	volumeExists := dsw.VolumeExists(generatedVolumeName, nodeName)
540	if !volumeExists {
541		t.Fatalf(
542			"Added pod %q to volume %q/node %q. Volume does not exist, it should.",
543			pod1Name,
544			generatedVolumeName,
545			nodeName)
546	}
547
548	// Act
549	dsw.DeletePod(types.UniquePodName(pod2Name), generatedVolumeName, nodeName)
550
551	// Assert
552	volumeExists = dsw.VolumeExists(generatedVolumeName, nodeName)
553	if !volumeExists {
554		t.Fatalf(
555			"Volume %q/node %q does not exist, it should.",
556			generatedVolumeName,
557			nodeName)
558	}
559
560	volumesToAttach := dsw.GetVolumesToAttach()
561	if len(volumesToAttach) != 1 {
562		t.Fatalf("len(volumesToAttach) Expected: <1> Actual: <%v>", len(volumesToAttach))
563	}
564
565	verifyVolumeToAttach(t, volumesToAttach, nodeName, generatedVolumeName, string(volumeName))
566}
567
568// Populates data struct with pod/volume/node1.
569// Calls DeleteNode() to delete the pod/volume/node2.
570// Verifies volume still exists, and one volumes to attach.
571func Test_DeletePod_Positive_NodeDoesNotExist(t *testing.T) {
572	// Arrange
573	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
574	dsw := NewDesiredStateOfWorld(volumePluginMgr)
575	podName := "pod-uid"
576	volumeName := v1.UniqueVolumeName("volume-name")
577	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
578	node1Name := k8stypes.NodeName("node1-name")
579	dsw.AddNode(node1Name, false /*keepTerminatedPodVolumes*/)
580	generatedVolumeName, podAddErr := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, node1Name)
581	if podAddErr != nil {
582		t.Fatalf(
583			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
584			podName,
585			podAddErr)
586	}
587	volumeExists := dsw.VolumeExists(generatedVolumeName, node1Name)
588	if !volumeExists {
589		t.Fatalf(
590			"Added pod %q to volume %q/node %q. Volume does not exist, it should.",
591			podName,
592			generatedVolumeName,
593			node1Name)
594	}
595	node2Name := k8stypes.NodeName("node2-name")
596
597	// Act
598	dsw.DeletePod(types.UniquePodName(podName), generatedVolumeName, node2Name)
599
600	// Assert
601	volumeExists = dsw.VolumeExists(generatedVolumeName, node1Name)
602	if !volumeExists {
603		t.Fatalf(
604			"Volume %q/node %q does not exist, it should.",
605			generatedVolumeName,
606			node1Name)
607	}
608	volumeExists = dsw.VolumeExists(generatedVolumeName, node2Name)
609	if volumeExists {
610		t.Fatalf(
611			"node %q exists, it should not.",
612			node2Name)
613	}
614
615	volumesToAttach := dsw.GetVolumesToAttach()
616	if len(volumesToAttach) != 1 {
617		t.Fatalf("len(volumesToAttach) Expected: <1> Actual: <%v>", len(volumesToAttach))
618	}
619
620	verifyVolumeToAttach(t, volumesToAttach, node1Name, generatedVolumeName, string(volumeName))
621}
622
623// Populates data struct with pod/volume1/node.
624// Calls DeleteNode() to delete the pod/volume2/node.
625// Verifies volume still exists, and one volumes to attach.
626func Test_DeletePod_Positive_VolumeDoesNotExist(t *testing.T) {
627	// Arrange
628	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
629	dsw := NewDesiredStateOfWorld(volumePluginMgr)
630	podName := "pod-uid"
631	volume1Name := v1.UniqueVolumeName("volume1-name")
632	volume1Spec := controllervolumetesting.GetTestVolumeSpec(string(volume1Name), volume1Name)
633	nodeName := k8stypes.NodeName("node-name")
634	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
635	generatedVolume1Name, podAddErr := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volume1Spec, nodeName)
636	if podAddErr != nil {
637		t.Fatalf(
638			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
639			podName,
640			podAddErr)
641	}
642	volumeExists := dsw.VolumeExists(generatedVolume1Name, nodeName)
643	if !volumeExists {
644		t.Fatalf(
645			"Added pod %q to volume %q/node %q. Volume does not exist, it should.",
646			podName,
647			generatedVolume1Name,
648			nodeName)
649	}
650	volume2Name := v1.UniqueVolumeName("volume2-name")
651
652	// Act
653	dsw.DeletePod(types.UniquePodName(podName), volume2Name, nodeName)
654
655	// Assert
656	volumeExists = dsw.VolumeExists(generatedVolume1Name, nodeName)
657	if !volumeExists {
658		t.Fatalf(
659			"Volume %q/node %q does not exist, it should.",
660			generatedVolume1Name,
661			nodeName)
662	}
663	volumeExists = dsw.VolumeExists(volume2Name, nodeName)
664	if volumeExists {
665		t.Fatalf(
666			"volume %q exists, it should not.",
667			volume2Name)
668	}
669
670	volumesToAttach := dsw.GetVolumesToAttach()
671	if len(volumesToAttach) != 1 {
672		t.Fatalf("len(volumesToAttach) Expected: <1> Actual: <%v>", len(volumesToAttach))
673	}
674
675	verifyVolumeToAttach(t, volumesToAttach, nodeName, generatedVolume1Name, string(volume1Name))
676}
677
678// Calls NodeExists() on random node.
679// Verifies node does not exist, and no volumes to attach.
680func Test_NodeExists_Positive_NodeExists(t *testing.T) {
681	// Arrange
682	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
683	dsw := NewDesiredStateOfWorld(volumePluginMgr)
684	notAddedNodeName := k8stypes.NodeName("node-not-added-name")
685
686	// Act
687	notAddedNodeExists := dsw.NodeExists(notAddedNodeName)
688
689	// Assert
690	if notAddedNodeExists {
691		t.Fatalf("Node %q exists, it should not.", notAddedNodeName)
692	}
693
694	volumesToAttach := dsw.GetVolumesToAttach()
695	if len(volumesToAttach) != 0 {
696		t.Fatalf("len(volumesToAttach) Expected: <0> Actual: <%v>", len(volumesToAttach))
697	}
698}
699
700// Populates data struct with a single node.
701// Calls NodeExists() on that node.
702// Verifies node exists, and no volumes to attach.
703func Test_NodeExists_Positive_NodeDoesntExist(t *testing.T) {
704	// Arrange
705	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
706	dsw := NewDesiredStateOfWorld(volumePluginMgr)
707	nodeName := k8stypes.NodeName("node-name")
708	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
709
710	// Act
711	nodeExists := dsw.NodeExists(nodeName)
712
713	// Assert
714	if !nodeExists {
715		t.Fatalf("Node %q does not exist, it should.", nodeName)
716	}
717
718	volumesToAttach := dsw.GetVolumesToAttach()
719	if len(volumesToAttach) != 0 {
720		t.Fatalf("len(volumesToAttach) Expected: <0> Actual: <%v>", len(volumesToAttach))
721	}
722}
723
724// Populates data struct with new pod/volume/node.
725// Calls VolumeExists() on that volume/node.
726// Verifies volume/node exists, and one volume to attach.
727func Test_VolumeExists_Positive_VolumeExistsNodeExists(t *testing.T) {
728	// Arrange
729	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
730	dsw := NewDesiredStateOfWorld(volumePluginMgr)
731	nodeName := k8stypes.NodeName("node-name")
732	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
733	podName := "pod-uid"
734	volumeName := v1.UniqueVolumeName("volume-name")
735	volumeSpec := controllervolumetesting.GetTestVolumeSpec(string(volumeName), volumeName)
736	generatedVolumeName, _ := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)
737
738	// Act
739	volumeExists := dsw.VolumeExists(generatedVolumeName, nodeName)
740
741	// Assert
742	if !volumeExists {
743		t.Fatalf("Volume %q does not exist, it should.", generatedVolumeName)
744	}
745
746	volumesToAttach := dsw.GetVolumesToAttach()
747	if len(volumesToAttach) != 1 {
748		t.Fatalf("len(volumesToAttach) Expected: <1> Actual: <%v>", len(volumesToAttach))
749	}
750
751	verifyVolumeToAttach(t, volumesToAttach, nodeName, generatedVolumeName, string(volumeName))
752}
753
754// Populates data struct with new pod/volume1/node.
755// Calls VolumeExists() on that volume2/node.
756// Verifies volume2/node does not exist, and one volume to attach.
757func Test_VolumeExists_Positive_VolumeDoesntExistNodeExists(t *testing.T) {
758	// Arrange
759	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
760	dsw := NewDesiredStateOfWorld(volumePluginMgr)
761	nodeName := k8stypes.NodeName("node-name")
762	dsw.AddNode(nodeName, false /*keepTerminatedPodVolumes*/)
763	podName := "pod-uid"
764	volume1Name := v1.UniqueVolumeName("volume1-name")
765	volume1Spec := controllervolumetesting.GetTestVolumeSpec(string(volume1Name), volume1Name)
766	generatedVolume1Name, podAddErr := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volume1Spec, nodeName)
767	if podAddErr != nil {
768		t.Fatalf(
769			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
770			podName,
771			podAddErr)
772	}
773	volume2Name := v1.UniqueVolumeName("volume2-name")
774
775	// Act
776	volumeExists := dsw.VolumeExists(volume2Name, nodeName)
777
778	// Assert
779	if volumeExists {
780		t.Fatalf("Volume %q exists, it should not.", volume2Name)
781	}
782
783	volumesToAttach := dsw.GetVolumesToAttach()
784	if len(volumesToAttach) != 1 {
785		t.Fatalf("len(volumesToAttach) Expected: <1> Actual: <%v>", len(volumesToAttach))
786	}
787
788	verifyVolumeToAttach(t, volumesToAttach, nodeName, generatedVolume1Name, string(volume1Name))
789}
790
791// Calls VolumeExists() on some volume/node.
792// Verifies volume/node do not exist, and zero volumes to attach.
793func Test_VolumeExists_Positive_VolumeDoesntExistNodeDoesntExists(t *testing.T) {
794	// Arrange
795	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
796	dsw := NewDesiredStateOfWorld(volumePluginMgr)
797	nodeName := k8stypes.NodeName("node-name")
798	volumeName := v1.UniqueVolumeName("volume-name")
799
800	// Act
801	volumeExists := dsw.VolumeExists(volumeName, nodeName)
802
803	// Assert
804	if volumeExists {
805		t.Fatalf("Volume %q exists, it should not.", volumeName)
806	}
807
808	volumesToAttach := dsw.GetVolumesToAttach()
809	if len(volumesToAttach) != 0 {
810		t.Fatalf("len(volumesToAttach) Expected: <0> Actual: <%v>", len(volumesToAttach))
811	}
812}
813
814// Calls GetVolumesToAttach()
815// Verifies zero volumes to attach.
816func Test_GetVolumesToAttach_Positive_NoNodes(t *testing.T) {
817	// Arrange
818	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
819	dsw := NewDesiredStateOfWorld(volumePluginMgr)
820
821	// Act
822	volumesToAttach := dsw.GetVolumesToAttach()
823
824	// Assert
825	if len(volumesToAttach) > 0 {
826		t.Fatalf("len(volumesToAttach) Expected: <0> Actual: <%v>", len(volumesToAttach))
827	}
828}
829
830// Populates data struct with two nodes.
831// Calls GetVolumesToAttach()
832// Verifies zero volumes to attach.
833func Test_GetVolumesToAttach_Positive_TwoNodes(t *testing.T) {
834	// Arrange
835	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
836	dsw := NewDesiredStateOfWorld(volumePluginMgr)
837	node1Name := k8stypes.NodeName("node1-name")
838	node2Name := k8stypes.NodeName("node2-name")
839	dsw.AddNode(node1Name, false /*keepTerminatedPodVolumes*/)
840	dsw.AddNode(node2Name, false /*keepTerminatedPodVolumes*/)
841
842	// Act
843	volumesToAttach := dsw.GetVolumesToAttach()
844
845	// Assert
846	if len(volumesToAttach) != 0 {
847		t.Fatalf("len(volumesToAttach) Expected: <0> Actual: <%v>", len(volumesToAttach))
848	}
849}
850
851// Populates data struct with two nodes with one volume/pod each.
852// Calls GetVolumesToAttach()
853// Verifies two volumes to attach.
854func Test_GetVolumesToAttach_Positive_TwoNodesOneVolumeEach(t *testing.T) {
855	// Arrange
856	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
857	dsw := NewDesiredStateOfWorld(volumePluginMgr)
858	node1Name := k8stypes.NodeName("node1-name")
859	pod1Name := "pod1-uid"
860	volume1Name := v1.UniqueVolumeName("volume1-name")
861	volume1Spec := controllervolumetesting.GetTestVolumeSpec(string(volume1Name), volume1Name)
862	dsw.AddNode(node1Name, false /*keepTerminatedPodVolumes*/)
863	generatedVolume1Name, podAddErr := dsw.AddPod(types.UniquePodName(pod1Name), controllervolumetesting.NewPod(pod1Name, pod1Name), volume1Spec, node1Name)
864	if podAddErr != nil {
865		t.Fatalf(
866			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
867			pod1Name,
868			podAddErr)
869	}
870	node2Name := k8stypes.NodeName("node2-name")
871	pod2Name := "pod2-uid"
872	volume2Name := v1.UniqueVolumeName("volume2-name")
873	volume2Spec := controllervolumetesting.GetTestVolumeSpec(string(volume2Name), volume2Name)
874	dsw.AddNode(node2Name, false /*keepTerminatedPodVolumes*/)
875	generatedVolume2Name, podAddErr := dsw.AddPod(types.UniquePodName(pod2Name), controllervolumetesting.NewPod(pod2Name, pod2Name), volume2Spec, node2Name)
876	if podAddErr != nil {
877		t.Fatalf(
878			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
879			pod2Name,
880			podAddErr)
881	}
882
883	// Act
884	volumesToAttach := dsw.GetVolumesToAttach()
885
886	// Assert
887	if len(volumesToAttach) != 2 {
888		t.Fatalf("len(volumesToAttach) Expected: <2> Actual: <%v>", len(volumesToAttach))
889	}
890
891	verifyVolumeToAttach(t, volumesToAttach, node1Name, generatedVolume1Name, string(volume1Name))
892	verifyVolumeToAttach(t, volumesToAttach, node2Name, generatedVolume2Name, string(volume2Name))
893}
894
895// Populates data struct with two nodes with one volume/pod each and an extra
896// pod for the second node/volume pair.
897// Calls GetVolumesToAttach()
898// Verifies two volumes to attach.
899func Test_GetVolumesToAttach_Positive_TwoNodesOneVolumeEachExtraPod(t *testing.T) {
900	// Arrange
901	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
902	dsw := NewDesiredStateOfWorld(volumePluginMgr)
903	node1Name := k8stypes.NodeName("node1-name")
904	pod1Name := "pod1-uid"
905	volume1Name := v1.UniqueVolumeName("volume1-name")
906	volume1Spec := controllervolumetesting.GetTestVolumeSpec(string(volume1Name), volume1Name)
907	dsw.AddNode(node1Name, false /*keepTerminatedPodVolumes*/)
908	generatedVolume1Name, podAddErr := dsw.AddPod(types.UniquePodName(pod1Name), controllervolumetesting.NewPod(pod1Name, pod1Name), volume1Spec, node1Name)
909	if podAddErr != nil {
910		t.Fatalf(
911			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
912			pod1Name,
913			podAddErr)
914	}
915	node2Name := k8stypes.NodeName("node2-name")
916	pod2Name := "pod2-uid"
917	volume2Name := v1.UniqueVolumeName("volume2-name")
918	volume2Spec := controllervolumetesting.GetTestVolumeSpec(string(volume2Name), volume2Name)
919	dsw.AddNode(node2Name, false /*keepTerminatedPodVolumes*/)
920	generatedVolume2Name, podAddErr := dsw.AddPod(types.UniquePodName(pod2Name), controllervolumetesting.NewPod(pod2Name, pod2Name), volume2Spec, node2Name)
921	if podAddErr != nil {
922		t.Fatalf(
923			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
924			pod2Name,
925			podAddErr)
926	}
927	pod3Name := "pod3-uid"
928	dsw.AddPod(types.UniquePodName(pod3Name), controllervolumetesting.NewPod(pod3Name, pod3Name), volume2Spec, node2Name)
929	_, podAddErr = dsw.AddPod(types.UniquePodName(pod3Name), controllervolumetesting.NewPod(pod3Name, pod3Name), volume2Spec, node2Name)
930	if podAddErr != nil {
931		t.Fatalf(
932			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
933			pod3Name,
934			podAddErr)
935	}
936
937	// Act
938	volumesToAttach := dsw.GetVolumesToAttach()
939
940	// Assert
941	if len(volumesToAttach) != 2 {
942		t.Fatalf("len(volumesToAttach) Expected: <2> Actual: <%v>", len(volumesToAttach))
943	}
944
945	verifyVolumeToAttach(t, volumesToAttach, node1Name, generatedVolume1Name, string(volume1Name))
946	verifyVolumeToAttach(t, volumesToAttach, node2Name, generatedVolume2Name, string(volume2Name))
947}
948
949// Populates data struct with two nodes with one volume/pod on one node and two
950// volume/pod pairs on the other node.
951// Calls GetVolumesToAttach()
952// Verifies three volumes to attach.
953func Test_GetVolumesToAttach_Positive_TwoNodesThreeVolumes(t *testing.T) {
954	// Arrange
955	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
956	dsw := NewDesiredStateOfWorld(volumePluginMgr)
957	node1Name := k8stypes.NodeName("node1-name")
958	pod1Name := "pod1-uid"
959	volume1Name := v1.UniqueVolumeName("volume1-name")
960	volume1Spec := controllervolumetesting.GetTestVolumeSpec(string(volume1Name), volume1Name)
961	dsw.AddNode(node1Name, false /*keepTerminatedPodVolumes*/)
962	generatedVolume1Name, podAddErr := dsw.AddPod(types.UniquePodName(pod1Name), controllervolumetesting.NewPod(pod1Name, pod1Name), volume1Spec, node1Name)
963	if podAddErr != nil {
964		t.Fatalf(
965			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
966			pod1Name,
967			podAddErr)
968	}
969	node2Name := k8stypes.NodeName("node2-name")
970	pod2aName := "pod2a-name"
971	volume2Name := v1.UniqueVolumeName("volume2-name")
972	volume2Spec := controllervolumetesting.GetTestVolumeSpec(string(volume2Name), volume2Name)
973	dsw.AddNode(node2Name, false /*keepTerminatedPodVolumes*/)
974	generatedVolume2Name1, podAddErr := dsw.AddPod(types.UniquePodName(pod2aName), controllervolumetesting.NewPod(pod2aName, pod2aName), volume2Spec, node2Name)
975	if podAddErr != nil {
976		t.Fatalf(
977			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
978			pod2aName,
979			podAddErr)
980	}
981	pod2bName := "pod2b-name"
982	generatedVolume2Name2, podAddErr := dsw.AddPod(types.UniquePodName(pod2bName), controllervolumetesting.NewPod(pod2bName, pod2bName), volume2Spec, node2Name)
983	if podAddErr != nil {
984		t.Fatalf(
985			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
986			pod2bName,
987			podAddErr)
988	}
989	if generatedVolume2Name1 != generatedVolume2Name2 {
990		t.Fatalf(
991			"Generated volume names for the same volume should be the same but they are not: %q and %q",
992			generatedVolume2Name1,
993			generatedVolume2Name2)
994	}
995	pod3Name := "pod3-uid"
996	volume3Name := v1.UniqueVolumeName("volume3-name")
997	volume3Spec := controllervolumetesting.GetTestVolumeSpec(string(volume3Name), volume3Name)
998	generatedVolume3Name, podAddErr := dsw.AddPod(types.UniquePodName(pod3Name), controllervolumetesting.NewPod(pod3Name, pod3Name), volume3Spec, node1Name)
999	if podAddErr != nil {
1000		t.Fatalf(
1001			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
1002			pod3Name,
1003			podAddErr)
1004	}
1005
1006	// Act
1007	volumesToAttach := dsw.GetVolumesToAttach()
1008
1009	// Assert
1010	if len(volumesToAttach) != 3 {
1011		t.Fatalf("len(volumesToAttach) Expected: <3> Actual: <%v>", len(volumesToAttach))
1012	}
1013
1014	verifyVolumeToAttach(t, volumesToAttach, node1Name, generatedVolume1Name, string(volume1Name))
1015	verifyVolumeToAttach(t, volumesToAttach, node2Name, generatedVolume2Name1, string(volume2Name))
1016	verifyVolumeToAttach(t, volumesToAttach, node1Name, generatedVolume3Name, string(volume3Name))
1017}
1018
1019func verifyVolumeToAttach(
1020	t *testing.T,
1021	volumesToAttach []VolumeToAttach,
1022	expectedNodeName k8stypes.NodeName,
1023	expectedVolumeName v1.UniqueVolumeName,
1024	expectedVolumeSpecName string) {
1025	for _, volumeToAttach := range volumesToAttach {
1026		if volumeToAttach.NodeName == expectedNodeName &&
1027			volumeToAttach.VolumeName == expectedVolumeName &&
1028			volumeToAttach.VolumeSpec.Name() == expectedVolumeSpecName {
1029			return
1030		}
1031	}
1032
1033	t.Fatalf("volumesToAttach (%v) should contain %q/%q. It does not.", volumesToAttach, expectedVolumeName, expectedNodeName)
1034}
1035
1036func Test_GetPodsOnNodes(t *testing.T) {
1037	volumePluginMgr, _ := volumetesting.GetTestVolumePluginMgr(t)
1038	dsw := NewDesiredStateOfWorld(volumePluginMgr)
1039
1040	// 2 nodes, each with one pod with a different volume
1041	node1Name := k8stypes.NodeName("node1-name")
1042	pod1Name := "pod1-uid"
1043	volume1Name := v1.UniqueVolumeName("volume1-name")
1044	volume1Spec := controllervolumetesting.GetTestVolumeSpec(string(volume1Name), volume1Name)
1045	dsw.AddNode(node1Name, false /*keepTerminatedPodVolumes*/)
1046	generatedVolume1Name, podAddErr := dsw.AddPod(types.UniquePodName(pod1Name), controllervolumetesting.NewPod(pod1Name, pod1Name), volume1Spec, node1Name)
1047	if podAddErr != nil {
1048		t.Fatalf(
1049			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
1050			pod1Name,
1051			podAddErr)
1052	}
1053	node2Name := k8stypes.NodeName("node2-name")
1054	pod2Name := "pod2-uid"
1055	volume2Name := v1.UniqueVolumeName("volume2-name")
1056	volume2Spec := controllervolumetesting.GetTestVolumeSpec(string(volume2Name), volume2Name)
1057	dsw.AddNode(node2Name, false /*keepTerminatedPodVolumes*/)
1058	_, podAddErr = dsw.AddPod(types.UniquePodName(pod2Name), controllervolumetesting.NewPod(pod2Name, pod2Name), volume2Spec, node2Name)
1059	if podAddErr != nil {
1060		t.Fatalf(
1061			"AddPod failed for pod %q. Expected: <no error> Actual: <%v>",
1062			pod2Name,
1063			podAddErr)
1064	}
1065
1066	// Third node without any pod
1067	node3Name := k8stypes.NodeName("node3-name")
1068	dsw.AddNode(node3Name, false /*keepTerminatedPodVolumes*/)
1069
1070	// Act
1071	pods := dsw.GetVolumePodsOnNodes([]k8stypes.NodeName{node1Name, node2Name, node3Name, "non-existing-node"}, generatedVolume1Name)
1072
1073	// Assert
1074	if len(pods) != 1 {
1075		t.Fatalf("Expected 1 pod, got %d", len(pods))
1076	}
1077	if pods[0].Name != pod1Name {
1078		t.Errorf("Expected pod %s/%s, got %s", pod1Name, pod1Name, pods[0].Name)
1079	}
1080}
1081