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