github.com/jghiloni/cli@v6.28.1-0.20170628223758-0ce05fe032a2+incompatible/actor/v2action/security_group_test.go (about) 1 package v2action_test 2 3 import ( 4 "errors" 5 "fmt" 6 7 . "code.cloudfoundry.org/cli/actor/v2action" 8 "code.cloudfoundry.org/cli/actor/v2action/v2actionfakes" 9 "code.cloudfoundry.org/cli/api/cloudcontroller/ccerror" 10 "code.cloudfoundry.org/cli/api/cloudcontroller/ccv2" 11 . "github.com/onsi/ginkgo" 12 . "github.com/onsi/gomega" 13 ) 14 15 var _ = Describe("Security Group Actions", func() { 16 var ( 17 actor *Actor 18 fakeCloudControllerClient *v2actionfakes.FakeCloudControllerClient 19 ) 20 21 BeforeEach(func() { 22 fakeCloudControllerClient = new(v2actionfakes.FakeCloudControllerClient) 23 actor = NewActor(fakeCloudControllerClient, nil) 24 }) 25 26 Describe("GetSecurityGroupsWithOrganizationSpaceAndLifecycle", func() { 27 var ( 28 secGroupOrgSpaces []SecurityGroupWithOrganizationSpaceAndLifecycle 29 includeStaging bool 30 warnings Warnings 31 err error 32 ) 33 34 JustBeforeEach(func() { 35 secGroupOrgSpaces, warnings, err = actor.GetSecurityGroupsWithOrganizationSpaceAndLifecycle(includeStaging) 36 }) 37 38 Context("when we do not include staging", func() { 39 BeforeEach(func() { 40 includeStaging = false 41 }) 42 }) 43 44 Context("when an error occurs getting security groups", func() { 45 var returnedError error 46 47 BeforeEach(func() { 48 returnedError = errors.New("get-security-groups-error") 49 fakeCloudControllerClient.GetSecurityGroupsReturns( 50 nil, 51 ccv2.Warnings{"warning-1", "warning-2"}, 52 returnedError, 53 ) 54 }) 55 56 It("returns the error and all warnings", func() { 57 Expect(err).To(MatchError(returnedError)) 58 Expect(warnings).To(ConsistOf("warning-1", "warning-2")) 59 }) 60 }) 61 62 Context("when an error occurs getting running spaces", func() { 63 var returnedError error 64 65 BeforeEach(func() { 66 fakeCloudControllerClient.GetSecurityGroupsReturns( 67 []ccv2.SecurityGroup{ 68 { 69 GUID: "security-group-guid-1", 70 Name: "security-group-1", 71 }, 72 }, 73 ccv2.Warnings{"warning-1", "warning-2"}, 74 nil, 75 ) 76 returnedError = errors.New("get-spaces-error") 77 fakeCloudControllerClient.GetRunningSpacesBySecurityGroupReturns( 78 nil, 79 ccv2.Warnings{"warning-3", "warning-4"}, 80 returnedError, 81 ) 82 }) 83 84 It("returns the error and all warnings", func() { 85 Expect(err).To(MatchError(returnedError)) 86 Expect(warnings).To(ConsistOf("warning-1", "warning-2", "warning-3", "warning-4")) 87 Expect(fakeCloudControllerClient.GetSecurityGroupsCallCount()).To(Equal(1)) 88 Expect(fakeCloudControllerClient.GetSecurityGroupsArgsForCall(0)).To(BeNil()) 89 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupCallCount()).To(Equal(1)) 90 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(0)).To(Equal("security-group-guid-1")) 91 }) 92 }) 93 94 Context("when an error occurs getting staging spaces", func() { 95 var returnedError error 96 97 BeforeEach(func() { 98 includeStaging = true 99 100 fakeCloudControllerClient.GetSecurityGroupsReturns( 101 []ccv2.SecurityGroup{ 102 { 103 GUID: "security-group-guid-1", 104 Name: "security-group-1", 105 }, 106 }, 107 ccv2.Warnings{"warning-1", "warning-2"}, 108 nil, 109 ) 110 returnedError = errors.New("get-staging-spaces-error") 111 fakeCloudControllerClient.GetStagingSpacesBySecurityGroupReturns( 112 nil, 113 ccv2.Warnings{"warning-3", "warning-4"}, 114 returnedError, 115 ) 116 }) 117 118 It("returns the error and all warnings", func() { 119 Expect(err).To(MatchError(returnedError)) 120 Expect(warnings).To(ConsistOf("warning-1", "warning-2", "warning-3", "warning-4")) 121 Expect(fakeCloudControllerClient.GetSecurityGroupsCallCount()).To(Equal(1)) 122 Expect(fakeCloudControllerClient.GetSecurityGroupsArgsForCall(0)).To(BeNil()) 123 Expect(fakeCloudControllerClient.GetStagingSpacesBySecurityGroupCallCount()).To(Equal(1)) 124 Expect(fakeCloudControllerClient.GetStagingSpacesBySecurityGroupArgsForCall(0)).To(Equal("security-group-guid-1")) 125 }) 126 }) 127 128 Context("when an error occurs getting an organization", func() { 129 var returnedError error 130 131 BeforeEach(func() { 132 includeStaging = true 133 134 fakeCloudControllerClient.GetSecurityGroupsReturns( 135 []ccv2.SecurityGroup{ 136 { 137 GUID: "security-group-guid-1", 138 Name: "security-group-1", 139 }, 140 }, 141 ccv2.Warnings{"warning-1", "warning-2"}, 142 nil, 143 ) 144 fakeCloudControllerClient.GetRunningSpacesBySecurityGroupReturns( 145 []ccv2.Space{ 146 { 147 GUID: "space-guid-11", 148 Name: "space-11", 149 OrganizationGUID: "org-guid-11", 150 }, 151 }, 152 ccv2.Warnings{"warning-3", "warning-4"}, 153 nil, 154 ) 155 fakeCloudControllerClient.GetStagingSpacesBySecurityGroupReturns( 156 []ccv2.Space{ 157 { 158 GUID: "space-guid-12", 159 Name: "space-12", 160 OrganizationGUID: "org-guid-12", 161 }, 162 }, 163 ccv2.Warnings{"warning-5", "warning-6"}, 164 nil, 165 ) 166 returnedError = errors.New("get-org-error") 167 fakeCloudControllerClient.GetOrganizationReturns( 168 ccv2.Organization{}, 169 ccv2.Warnings{"warning-7", "warning-8"}, 170 returnedError, 171 ) 172 }) 173 174 It("returns the error and all warnings", func() { 175 Expect(err).To(MatchError(returnedError)) 176 Expect(warnings).To(ConsistOf("warning-1", "warning-2", "warning-3", "warning-4", "warning-5", "warning-6", "warning-7", "warning-8")) 177 Expect(fakeCloudControllerClient.GetSecurityGroupsCallCount()).To(Equal(1)) 178 Expect(fakeCloudControllerClient.GetSecurityGroupsArgsForCall(0)).To(BeNil()) 179 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupCallCount()).To(Equal(1)) 180 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(0)).To(Equal("security-group-guid-1")) 181 Expect(fakeCloudControllerClient.GetStagingSpacesBySecurityGroupCallCount()).To(Equal(1)) 182 Expect(fakeCloudControllerClient.GetStagingSpacesBySecurityGroupArgsForCall(0)).To(Equal("security-group-guid-1")) 183 Expect(fakeCloudControllerClient.GetOrganizationCallCount()).To(Equal(1)) 184 Expect(fakeCloudControllerClient.GetOrganizationArgsForCall(0)).To(Equal("org-guid-11")) 185 }) 186 }) 187 188 Context("when no errors are encountered", func() { 189 var ( 190 expectedSecurityGroup1 SecurityGroup 191 expectedSecurityGroup2 SecurityGroup 192 expectedSecurityGroup3 SecurityGroup 193 expectedSecurityGroup4 SecurityGroup 194 expectedSecurityGroup5 SecurityGroup 195 expectedSecurityGroup6 SecurityGroup 196 expectedSecurityGroup7 SecurityGroup 197 198 expectedOrg11 Organization 199 expectedOrg12 Organization 200 expectedOrg13 Organization 201 expectedOrg21 Organization 202 expectedOrg23 Organization 203 expectedOrg33 Organization 204 expectedOrgAll Organization 205 206 expectedSpace11 Space 207 expectedSpace12 Space 208 expectedSpace13 Space 209 expectedSpace21 Space 210 expectedSpace22 Space 211 expectedSpace23 Space 212 expectedSpace31 Space 213 expectedSpace32 Space 214 expectedSpace33 Space 215 expectedSpaceAll Space 216 ) 217 218 BeforeEach(func() { 219 expectedSecurityGroup1 = SecurityGroup{ 220 GUID: "security-group-guid-1", 221 Name: "security-group-1", 222 RunningDefault: true, 223 } 224 expectedSecurityGroup2 = SecurityGroup{ 225 GUID: "security-group-guid-2", 226 Name: "security-group-2", 227 StagingDefault: true, 228 } 229 expectedSecurityGroup3 = SecurityGroup{ 230 GUID: "security-group-guid-3", 231 Name: "security-group-3", 232 } 233 expectedSecurityGroup4 = SecurityGroup{ 234 GUID: "security-group-guid-4", 235 Name: "security-group-4", 236 } 237 expectedSecurityGroup5 = SecurityGroup{ 238 GUID: "security-group-guid-5", 239 Name: "security-group-5", 240 RunningDefault: true, 241 } 242 expectedSecurityGroup6 = SecurityGroup{ 243 GUID: "security-group-guid-6", 244 Name: "security-group-6", 245 StagingDefault: true, 246 } 247 expectedSecurityGroup7 = SecurityGroup{ 248 GUID: "security-group-guid-7", 249 Name: "security-group-7", 250 RunningDefault: true, 251 StagingDefault: true, 252 } 253 254 expectedOrg11 = Organization{ 255 GUID: "<<org-guid-11", 256 Name: "org-11", 257 } 258 expectedOrg12 = Organization{ 259 GUID: "org-guid-12", 260 Name: "org-12", 261 } 262 expectedOrg13 = Organization{ 263 GUID: "org-guid-13", 264 Name: "org-13", 265 } 266 expectedOrg21 = Organization{ 267 GUID: "org-guid-21", 268 Name: "org-21", 269 } 270 expectedOrg23 = Organization{ 271 GUID: "org-guid-23", 272 Name: "org-23", 273 } 274 expectedOrg33 = Organization{ 275 GUID: "org-guid-33", 276 Name: "org-33", 277 } 278 expectedOrgAll = Organization{ 279 Name: "", 280 } 281 282 expectedSpace11 = Space{ 283 GUID: "space-guid-11", 284 Name: "space-11", 285 } 286 expectedSpace12 = Space{ 287 GUID: "space-guid-12", 288 Name: "space-12", 289 } 290 expectedSpace13 = Space{ 291 GUID: "space-guid-13", 292 Name: "space-13", 293 } 294 expectedSpace21 = Space{ 295 GUID: "space-guid-21", 296 Name: "space-21", 297 } 298 expectedSpace22 = Space{ 299 GUID: "space-guid-22", 300 Name: "space-22", 301 } 302 expectedSpace23 = Space{ 303 GUID: "space-guid-23", 304 Name: "space-23", 305 } 306 expectedSpace31 = Space{ 307 GUID: "space-guid-31", 308 Name: "space-31", 309 } 310 expectedSpace32 = Space{ 311 GUID: "space-guid-32", 312 Name: "space-32", 313 } 314 expectedSpace33 = Space{ 315 GUID: "space-guid-33", 316 Name: "space-33", 317 } 318 expectedSpaceAll = Space{ 319 Name: "", 320 } 321 322 fakeCloudControllerClient.GetSecurityGroupsReturns( 323 []ccv2.SecurityGroup{ 324 { 325 GUID: "security-group-guid-1", 326 Name: "security-group-1", 327 RunningDefault: true, 328 }, 329 { 330 GUID: "security-group-guid-2", 331 Name: "security-group-2", 332 StagingDefault: true, 333 }, 334 { 335 GUID: "security-group-guid-3", 336 Name: "security-group-3", 337 }, 338 { 339 GUID: "security-group-guid-4", 340 Name: "security-group-4", 341 }, 342 { 343 GUID: "security-group-guid-5", 344 Name: "security-group-5", 345 RunningDefault: true, 346 }, 347 { 348 GUID: "security-group-guid-6", 349 Name: "security-group-6", 350 StagingDefault: true, 351 }, 352 { 353 GUID: "security-group-guid-7", 354 Name: "security-group-7", 355 RunningDefault: true, 356 StagingDefault: true, 357 }, 358 }, 359 ccv2.Warnings{"warning-1", "warning-2"}, 360 nil, 361 ) 362 fakeCloudControllerClient.GetRunningSpacesBySecurityGroupReturnsOnCall(0, 363 []ccv2.Space{ 364 { 365 GUID: "space-guid-13", 366 Name: "space-13", 367 OrganizationGUID: "org-guid-13", 368 }, 369 { 370 GUID: "space-guid-12", 371 Name: "space-12", 372 OrganizationGUID: "org-guid-12", 373 }, 374 { 375 GUID: "space-guid-11", 376 Name: "space-11", 377 OrganizationGUID: "<<org-guid-11", 378 }, 379 }, 380 ccv2.Warnings{"warning-3", "warning-4"}, 381 nil, 382 ) 383 384 fakeCloudControllerClient.GetStagingSpacesBySecurityGroupReturnsOnCall(0, 385 []ccv2.Space{ 386 { 387 GUID: "space-guid-13", 388 Name: "space-13", 389 OrganizationGUID: "org-guid-13", 390 }, 391 { 392 GUID: "space-guid-12", 393 Name: "space-12", 394 OrganizationGUID: "org-guid-12", 395 }, 396 { 397 GUID: "space-guid-11", 398 Name: "space-11", 399 OrganizationGUID: "<<org-guid-11", 400 }, 401 }, 402 ccv2.Warnings{"warning-5", "warning-6"}, 403 nil, 404 ) 405 406 fakeCloudControllerClient.GetRunningSpacesBySecurityGroupReturnsOnCall(1, 407 []ccv2.Space{ 408 { 409 GUID: "space-guid-21", 410 Name: "space-21", 411 OrganizationGUID: "org-guid-21", 412 }, 413 { 414 GUID: "space-guid-23", 415 Name: "space-23", 416 OrganizationGUID: "org-guid-23", 417 }, 418 { 419 GUID: "space-guid-22", 420 Name: "space-22", 421 OrganizationGUID: "<<org-guid-11", 422 }, 423 }, 424 ccv2.Warnings{"warning-7", "warning-8"}, 425 nil, 426 ) 427 fakeCloudControllerClient.GetRunningSpacesBySecurityGroupReturnsOnCall(2, 428 []ccv2.Space{}, 429 ccv2.Warnings{"warning-9", "warning-10"}, 430 nil, 431 ) 432 fakeCloudControllerClient.GetRunningSpacesBySecurityGroupReturnsOnCall(3, 433 []ccv2.Space{ 434 { 435 GUID: "space-guid-31", 436 Name: "space-31", 437 OrganizationGUID: "org-guid-23", 438 }, 439 { 440 GUID: "space-guid-32", 441 Name: "space-32", 442 OrganizationGUID: "<<org-guid-11", 443 }, 444 { 445 GUID: "space-guid-33", 446 Name: "space-33", 447 OrganizationGUID: "org-guid-33", 448 }, 449 }, 450 ccv2.Warnings{"warning-11", "warning-12"}, 451 nil, 452 ) 453 fakeCloudControllerClient.GetRunningSpacesBySecurityGroupReturnsOnCall(4, 454 []ccv2.Space{}, 455 ccv2.Warnings{"warning-31", "warning-32"}, 456 nil, 457 ) 458 fakeCloudControllerClient.GetRunningSpacesBySecurityGroupReturnsOnCall(5, 459 []ccv2.Space{}, 460 ccv2.Warnings{"warning-33", "warning-34"}, 461 nil, 462 ) 463 fakeCloudControllerClient.GetRunningSpacesBySecurityGroupReturnsOnCall(6, 464 []ccv2.Space{}, 465 ccv2.Warnings{"warning-35", "warning-36"}, 466 nil, 467 ) 468 fakeCloudControllerClient.GetOrganizationReturnsOnCall(0, 469 ccv2.Organization{ 470 GUID: "org-guid-13", 471 Name: "org-13", 472 }, 473 ccv2.Warnings{"warning-13", "warning-14"}, 474 nil, 475 ) 476 fakeCloudControllerClient.GetOrganizationReturnsOnCall(1, 477 ccv2.Organization{ 478 GUID: "org-guid-12", 479 Name: "org-12", 480 }, 481 ccv2.Warnings{"warning-15", "warning-16"}, 482 nil, 483 ) 484 fakeCloudControllerClient.GetOrganizationReturnsOnCall(2, 485 ccv2.Organization{ 486 GUID: "<<org-guid-11", 487 Name: "org-11", 488 }, 489 ccv2.Warnings{"warning-17", "warning-18"}, 490 nil, 491 ) 492 fakeCloudControllerClient.GetOrganizationReturnsOnCall(3, 493 ccv2.Organization{ 494 GUID: "org-guid-21", 495 Name: "org-21", 496 }, 497 ccv2.Warnings{"warning-19", "warning-20"}, 498 nil, 499 ) 500 fakeCloudControllerClient.GetOrganizationReturnsOnCall(4, 501 ccv2.Organization{ 502 GUID: "org-guid-23", 503 Name: "org-23", 504 }, 505 ccv2.Warnings{"warning-21", "warning-22"}, 506 nil, 507 ) 508 fakeCloudControllerClient.GetOrganizationReturnsOnCall(5, 509 ccv2.Organization{ 510 GUID: "org-guid-33", 511 Name: "org-33", 512 }, 513 ccv2.Warnings{"warning-25", "warning-26"}, 514 nil, 515 ) 516 }) 517 518 Context("when security groups bound to spaces in the staging lifecycle are included", func() { 519 BeforeEach(func() { 520 includeStaging = true 521 }) 522 523 It("returns a slice of SecurityGroupWithOrganizationSpaceAndLifecycle and all warnings", func() { 524 Expect(err).NotTo(HaveOccurred()) 525 Expect(warnings).To(ConsistOf( 526 "warning-1", "warning-2", 527 "warning-3", "warning-4", 528 "warning-5", "warning-6", 529 "warning-7", "warning-8", 530 "warning-9", "warning-10", 531 "warning-11", "warning-12", 532 "warning-13", "warning-14", 533 "warning-15", "warning-16", 534 "warning-17", "warning-18", 535 "warning-19", "warning-20", 536 "warning-21", "warning-22", 537 "warning-25", "warning-26", 538 "warning-31", "warning-32", 539 "warning-33", "warning-34", 540 "warning-35", "warning-36", 541 )) 542 expected := []SecurityGroupWithOrganizationSpaceAndLifecycle{ 543 { 544 SecurityGroup: &expectedSecurityGroup1, 545 Organization: &expectedOrgAll, 546 Space: &expectedSpaceAll, 547 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 548 }, 549 { 550 SecurityGroup: &expectedSecurityGroup1, 551 Organization: &expectedOrg11, 552 Space: &expectedSpace11, 553 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 554 }, 555 { 556 SecurityGroup: &expectedSecurityGroup1, 557 Organization: &expectedOrg11, 558 Space: &expectedSpace11, 559 Lifecycle: ccv2.SecurityGroupLifecycleStaging, 560 }, 561 { 562 SecurityGroup: &expectedSecurityGroup1, 563 Organization: &expectedOrg12, 564 Space: &expectedSpace12, 565 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 566 }, 567 { 568 SecurityGroup: &expectedSecurityGroup1, 569 Organization: &expectedOrg12, 570 Space: &expectedSpace12, 571 Lifecycle: ccv2.SecurityGroupLifecycleStaging, 572 }, 573 { 574 SecurityGroup: &expectedSecurityGroup1, 575 Organization: &expectedOrg13, 576 Space: &expectedSpace13, 577 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 578 }, 579 { 580 SecurityGroup: &expectedSecurityGroup1, 581 Organization: &expectedOrg13, 582 Space: &expectedSpace13, 583 Lifecycle: ccv2.SecurityGroupLifecycleStaging, 584 }, 585 { 586 SecurityGroup: &expectedSecurityGroup2, 587 Organization: &expectedOrgAll, 588 Space: &expectedSpaceAll, 589 Lifecycle: ccv2.SecurityGroupLifecycleStaging, 590 }, 591 { 592 SecurityGroup: &expectedSecurityGroup2, 593 Organization: &expectedOrg11, 594 Space: &expectedSpace22, 595 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 596 }, 597 { 598 SecurityGroup: &expectedSecurityGroup2, 599 Organization: &expectedOrg21, 600 Space: &expectedSpace21, 601 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 602 }, 603 { 604 SecurityGroup: &expectedSecurityGroup2, 605 Organization: &expectedOrg23, 606 Space: &expectedSpace23, 607 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 608 }, 609 { 610 SecurityGroup: &expectedSecurityGroup3, 611 Organization: &Organization{}, 612 Space: &Space{}, 613 }, 614 { 615 SecurityGroup: &expectedSecurityGroup4, 616 Organization: &expectedOrg11, 617 Space: &expectedSpace32, 618 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 619 }, 620 { 621 SecurityGroup: &expectedSecurityGroup4, 622 Organization: &expectedOrg23, 623 Space: &expectedSpace31, 624 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 625 }, 626 { 627 SecurityGroup: &expectedSecurityGroup4, 628 Organization: &expectedOrg33, 629 Space: &expectedSpace33, 630 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 631 }, 632 { 633 SecurityGroup: &expectedSecurityGroup5, 634 Organization: &expectedOrgAll, 635 Space: &expectedSpaceAll, 636 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 637 }, 638 { 639 SecurityGroup: &expectedSecurityGroup6, 640 Organization: &expectedOrgAll, 641 Space: &expectedSpaceAll, 642 Lifecycle: ccv2.SecurityGroupLifecycleStaging, 643 }, 644 { 645 SecurityGroup: &expectedSecurityGroup7, 646 Organization: &expectedOrgAll, 647 Space: &expectedSpaceAll, 648 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 649 }, 650 { 651 SecurityGroup: &expectedSecurityGroup7, 652 Organization: &expectedOrgAll, 653 Space: &expectedSpaceAll, 654 Lifecycle: ccv2.SecurityGroupLifecycleStaging, 655 }, 656 } 657 Expect(secGroupOrgSpaces).To(Equal(expected)) 658 Expect(fakeCloudControllerClient.GetSecurityGroupsCallCount()).To(Equal(1)) 659 Expect(fakeCloudControllerClient.GetSecurityGroupsArgsForCall(0)).To(BeNil()) 660 661 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupCallCount()).To(Equal(7)) 662 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(0)).To(Equal("security-group-guid-1")) 663 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(1)).To(Equal("security-group-guid-2")) 664 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(2)).To(Equal("security-group-guid-3")) 665 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(3)).To(Equal("security-group-guid-4")) 666 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(4)).To(Equal("security-group-guid-5")) 667 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(5)).To(Equal("security-group-guid-6")) 668 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(6)).To(Equal("security-group-guid-7")) 669 670 Expect(fakeCloudControllerClient.GetStagingSpacesBySecurityGroupCallCount()).To(Equal(7)) 671 Expect(fakeCloudControllerClient.GetStagingSpacesBySecurityGroupArgsForCall(0)).To(Equal("security-group-guid-1")) 672 Expect(fakeCloudControllerClient.GetStagingSpacesBySecurityGroupArgsForCall(1)).To(Equal("security-group-guid-2")) 673 Expect(fakeCloudControllerClient.GetStagingSpacesBySecurityGroupArgsForCall(2)).To(Equal("security-group-guid-3")) 674 Expect(fakeCloudControllerClient.GetStagingSpacesBySecurityGroupArgsForCall(3)).To(Equal("security-group-guid-4")) 675 Expect(fakeCloudControllerClient.GetStagingSpacesBySecurityGroupArgsForCall(4)).To(Equal("security-group-guid-5")) 676 Expect(fakeCloudControllerClient.GetStagingSpacesBySecurityGroupArgsForCall(5)).To(Equal("security-group-guid-6")) 677 Expect(fakeCloudControllerClient.GetStagingSpacesBySecurityGroupArgsForCall(6)).To(Equal("security-group-guid-7")) 678 679 Expect(fakeCloudControllerClient.GetOrganizationCallCount()).To(Equal(6)) 680 Expect(fakeCloudControllerClient.GetOrganizationArgsForCall(0)).To(Equal("org-guid-13")) 681 Expect(fakeCloudControllerClient.GetOrganizationArgsForCall(1)).To(Equal("org-guid-12")) 682 Expect(fakeCloudControllerClient.GetOrganizationArgsForCall(2)).To(Equal("<<org-guid-11")) 683 Expect(fakeCloudControllerClient.GetOrganizationArgsForCall(3)).To(Equal("org-guid-21")) 684 Expect(fakeCloudControllerClient.GetOrganizationArgsForCall(4)).To(Equal("org-guid-23")) 685 Expect(fakeCloudControllerClient.GetOrganizationArgsForCall(5)).To(Equal("org-guid-33")) 686 }) 687 }) 688 689 Context("when security groups bound to spaces in the staging lifecycle phase are not included", func() { 690 BeforeEach(func() { 691 includeStaging = false 692 }) 693 694 It("returns a slice of SecurityGroupWithOrganizationSpaceAndLifecycle, excluding any which are bound only in the staging lifecycle phase, and all warnings", func() { 695 Expect(err).NotTo(HaveOccurred()) 696 Expect(warnings).To(ConsistOf( 697 "warning-1", "warning-2", 698 "warning-3", "warning-4", 699 "warning-7", "warning-8", 700 "warning-9", "warning-10", 701 "warning-11", "warning-12", 702 "warning-13", "warning-14", 703 "warning-15", "warning-16", 704 "warning-17", "warning-18", 705 "warning-19", "warning-20", 706 "warning-21", "warning-22", 707 "warning-25", "warning-26", 708 "warning-31", "warning-32", 709 "warning-33", "warning-34", 710 "warning-35", "warning-36", 711 )) 712 713 expected := []SecurityGroupWithOrganizationSpaceAndLifecycle{ 714 { 715 SecurityGroup: &expectedSecurityGroup1, 716 Organization: &expectedOrgAll, 717 Space: &expectedSpaceAll, 718 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 719 }, 720 { 721 SecurityGroup: &expectedSecurityGroup1, 722 Organization: &expectedOrg11, 723 Space: &expectedSpace11, 724 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 725 }, 726 { 727 SecurityGroup: &expectedSecurityGroup1, 728 Organization: &expectedOrg12, 729 Space: &expectedSpace12, 730 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 731 }, 732 { 733 SecurityGroup: &expectedSecurityGroup1, 734 Organization: &expectedOrg13, 735 Space: &expectedSpace13, 736 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 737 }, 738 { 739 SecurityGroup: &expectedSecurityGroup2, 740 Organization: &expectedOrgAll, 741 Space: &expectedSpaceAll, 742 Lifecycle: ccv2.SecurityGroupLifecycleStaging, 743 }, 744 { 745 SecurityGroup: &expectedSecurityGroup2, 746 Organization: &expectedOrg11, 747 Space: &expectedSpace22, 748 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 749 }, 750 { 751 SecurityGroup: &expectedSecurityGroup2, 752 Organization: &expectedOrg21, 753 Space: &expectedSpace21, 754 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 755 }, 756 { 757 SecurityGroup: &expectedSecurityGroup2, 758 Organization: &expectedOrg23, 759 Space: &expectedSpace23, 760 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 761 }, 762 { 763 SecurityGroup: &expectedSecurityGroup3, 764 Organization: &Organization{}, 765 Space: &Space{}, 766 }, 767 { 768 SecurityGroup: &expectedSecurityGroup4, 769 Organization: &expectedOrg11, 770 Space: &expectedSpace32, 771 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 772 }, 773 { 774 SecurityGroup: &expectedSecurityGroup4, 775 Organization: &expectedOrg23, 776 Space: &expectedSpace31, 777 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 778 }, 779 { 780 SecurityGroup: &expectedSecurityGroup4, 781 Organization: &expectedOrg33, 782 Space: &expectedSpace33, 783 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 784 }, 785 { 786 SecurityGroup: &expectedSecurityGroup5, 787 Organization: &expectedOrgAll, 788 Space: &expectedSpaceAll, 789 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 790 }, 791 { 792 SecurityGroup: &expectedSecurityGroup6, 793 Organization: &expectedOrgAll, 794 Space: &expectedSpaceAll, 795 Lifecycle: ccv2.SecurityGroupLifecycleStaging, 796 }, 797 { 798 SecurityGroup: &expectedSecurityGroup7, 799 Organization: &expectedOrgAll, 800 Space: &expectedSpaceAll, 801 Lifecycle: ccv2.SecurityGroupLifecycleRunning, 802 }, 803 { 804 SecurityGroup: &expectedSecurityGroup7, 805 Organization: &expectedOrgAll, 806 Space: &expectedSpaceAll, 807 Lifecycle: ccv2.SecurityGroupLifecycleStaging, 808 }, 809 } 810 Expect(secGroupOrgSpaces).To(Equal(expected)) 811 Expect(fakeCloudControllerClient.GetSecurityGroupsCallCount()).To(Equal(1)) 812 Expect(fakeCloudControllerClient.GetSecurityGroupsArgsForCall(0)).To(BeNil()) 813 814 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupCallCount()).To(Equal(7)) 815 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(0)).To(Equal("security-group-guid-1")) 816 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(1)).To(Equal("security-group-guid-2")) 817 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(2)).To(Equal("security-group-guid-3")) 818 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(3)).To(Equal("security-group-guid-4")) 819 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(4)).To(Equal("security-group-guid-5")) 820 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(5)).To(Equal("security-group-guid-6")) 821 Expect(fakeCloudControllerClient.GetRunningSpacesBySecurityGroupArgsForCall(6)).To(Equal("security-group-guid-7")) 822 823 Expect(fakeCloudControllerClient.GetStagingSpacesBySecurityGroupCallCount()).To(Equal(0)) 824 825 Expect(fakeCloudControllerClient.GetOrganizationCallCount()).To(Equal(6)) 826 Expect(fakeCloudControllerClient.GetOrganizationArgsForCall(0)).To(Equal("org-guid-13")) 827 Expect(fakeCloudControllerClient.GetOrganizationArgsForCall(1)).To(Equal("org-guid-12")) 828 Expect(fakeCloudControllerClient.GetOrganizationArgsForCall(2)).To(Equal("<<org-guid-11")) 829 Expect(fakeCloudControllerClient.GetOrganizationArgsForCall(3)).To(Equal("org-guid-21")) 830 Expect(fakeCloudControllerClient.GetOrganizationArgsForCall(4)).To(Equal("org-guid-23")) 831 Expect(fakeCloudControllerClient.GetOrganizationArgsForCall(5)).To(Equal("org-guid-33")) 832 }) 833 }) 834 }) 835 }) 836 837 Describe("GetSecurityGroupByName", func() { 838 var ( 839 securityGroup SecurityGroup 840 warnings Warnings 841 err error 842 ) 843 844 JustBeforeEach(func() { 845 securityGroup, warnings, err = actor.GetSecurityGroupByName("some-security-group") 846 }) 847 848 Context("when the security group exists", func() { 849 BeforeEach(func() { 850 fakeCloudControllerClient.GetSecurityGroupsReturns( 851 []ccv2.SecurityGroup{ 852 { 853 GUID: "some-security-group-guid", 854 Name: "some-security-group", 855 }, 856 }, 857 ccv2.Warnings{"warning-1", "warning-2"}, 858 nil, 859 ) 860 }) 861 862 It("returns the security group and all warnings", func() { 863 Expect(err).ToNot(HaveOccurred()) 864 Expect(securityGroup.GUID).To(Equal("some-security-group-guid")) 865 Expect(warnings).To(ConsistOf("warning-1", "warning-2")) 866 867 Expect(fakeCloudControllerClient.GetSecurityGroupsCallCount()).To(Equal(1)) 868 query := fakeCloudControllerClient.GetSecurityGroupsArgsForCall(0) 869 Expect(query).To(Equal( 870 []ccv2.Query{{ 871 Filter: ccv2.NameFilter, 872 Operator: ccv2.EqualOperator, 873 Value: "some-security-group", 874 }})) 875 }) 876 }) 877 878 Context("when the security group does not exist", func() { 879 BeforeEach(func() { 880 fakeCloudControllerClient.GetSecurityGroupsReturns( 881 []ccv2.SecurityGroup{}, 882 ccv2.Warnings{"warning-1", "warning-2"}, 883 nil, 884 ) 885 }) 886 887 It("returns a SecurityGroupNotFound error", func() { 888 Expect(err).To(MatchError(SecurityGroupNotFoundError{Name: "some-security-group"})) 889 Expect(warnings).To(ConsistOf("warning-1", "warning-2")) 890 }) 891 }) 892 893 Context("an error occurs", func() { 894 var returnedError error 895 896 BeforeEach(func() { 897 returnedError = errors.New("get-security-groups-error") 898 fakeCloudControllerClient.GetSecurityGroupsReturns( 899 []ccv2.SecurityGroup{}, 900 ccv2.Warnings{"warning-1", "warning-2"}, 901 returnedError, 902 ) 903 }) 904 905 It("returns the error and all warnings", func() { 906 Expect(err).To(MatchError(returnedError)) 907 Expect(warnings).To(ConsistOf("warning-1", "warning-2")) 908 }) 909 }) 910 }) 911 912 Describe("BindSecurityGroupToSpace", func() { 913 var ( 914 lifecycle ccv2.SecurityGroupLifecycle 915 err error 916 warnings []string 917 ) 918 919 JustBeforeEach(func() { 920 warnings, err = actor.BindSecurityGroupToSpace("some-security-group-guid", "some-space-guid", lifecycle) 921 }) 922 923 Context("when the lifecycle is neither running nor staging", func() { 924 BeforeEach(func() { 925 lifecycle = "bill & ted" 926 }) 927 928 It("returns and appropriate error", func() { 929 Expect(err).To(MatchError(fmt.Sprintf("Invalid lifecycle: %s", lifecycle))) 930 }) 931 }) 932 933 Context("when the lifecycle is running", func() { 934 BeforeEach(func() { 935 lifecycle = ccv2.SecurityGroupLifecycleRunning 936 }) 937 938 Context("when binding the space does not return an error", func() { 939 BeforeEach(func() { 940 fakeCloudControllerClient.AssociateSpaceWithRunningSecurityGroupReturns( 941 ccv2.Warnings{"warning-1", "warning-2"}, 942 nil, 943 ) 944 }) 945 946 It("returns warnings and no error", func() { 947 Expect(err).ToNot(HaveOccurred()) 948 Expect(warnings).To(ConsistOf("warning-1", "warning-2")) 949 Expect(fakeCloudControllerClient.AssociateSpaceWithRunningSecurityGroupCallCount()).To(Equal(1)) 950 securityGroupGUID, spaceGUID := fakeCloudControllerClient.AssociateSpaceWithRunningSecurityGroupArgsForCall(0) 951 Expect(securityGroupGUID).To(Equal("some-security-group-guid")) 952 Expect(spaceGUID).To(Equal("some-space-guid")) 953 }) 954 }) 955 956 Context("when binding the space returns an error", func() { 957 var returnedError error 958 BeforeEach(func() { 959 returnedError = errors.New("associate-space-error") 960 fakeCloudControllerClient.AssociateSpaceWithRunningSecurityGroupReturns( 961 ccv2.Warnings{"warning-1", "warning-2"}, 962 returnedError, 963 ) 964 }) 965 966 It("returns the error and warnings", func() { 967 Expect(err).To(Equal(returnedError)) 968 Expect(warnings).To(ConsistOf("warning-1", "warning-2")) 969 }) 970 }) 971 }) 972 973 Context("when the lifecycle is staging", func() { 974 BeforeEach(func() { 975 lifecycle = ccv2.SecurityGroupLifecycleStaging 976 }) 977 978 Context("when binding the space does not return an error", func() { 979 BeforeEach(func() { 980 fakeCloudControllerClient.AssociateSpaceWithStagingSecurityGroupReturns( 981 ccv2.Warnings{"warning-1", "warning-2"}, 982 nil, 983 ) 984 }) 985 986 It("returns warnings and no error", func() { 987 Expect(err).ToNot(HaveOccurred()) 988 Expect(warnings).To(ConsistOf("warning-1", "warning-2")) 989 Expect(fakeCloudControllerClient.AssociateSpaceWithStagingSecurityGroupCallCount()).To(Equal(1)) 990 securityGroupGUID, spaceGUID := fakeCloudControllerClient.AssociateSpaceWithStagingSecurityGroupArgsForCall(0) 991 Expect(securityGroupGUID).To(Equal("some-security-group-guid")) 992 Expect(spaceGUID).To(Equal("some-space-guid")) 993 }) 994 }) 995 996 Context("when binding the space returns an error", func() { 997 var returnedError error 998 BeforeEach(func() { 999 returnedError = errors.New("associate-space-error") 1000 fakeCloudControllerClient.AssociateSpaceWithStagingSecurityGroupReturns( 1001 ccv2.Warnings{"warning-1", "warning-2"}, 1002 returnedError, 1003 ) 1004 }) 1005 1006 It("returns the error and warnings", func() { 1007 Expect(err).To(Equal(returnedError)) 1008 Expect(warnings).To(ConsistOf("warning-1", "warning-2")) 1009 }) 1010 }) 1011 }) 1012 }) 1013 1014 Describe("GetSpaceRunningSecurityGroupsBySpace", func() { 1015 Context("when the space exists and there are no errors", func() { 1016 BeforeEach(func() { 1017 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 1018 []ccv2.SecurityGroup{ 1019 { 1020 Name: "some-shared-security-group", 1021 }, 1022 { 1023 Name: "some-running-security-group", 1024 }, 1025 }, 1026 ccv2.Warnings{"warning-1", "warning-2"}, 1027 nil, 1028 ) 1029 }) 1030 1031 It("returns the security groups and warnings", func() { 1032 securityGroups, warnings, err := actor.GetSpaceRunningSecurityGroupsBySpace("space-guid") 1033 Expect(err).NotTo(HaveOccurred()) 1034 Expect(warnings).To(ConsistOf([]string{"warning-1", "warning-2"})) 1035 Expect(securityGroups).To(Equal( 1036 []SecurityGroup{ 1037 { 1038 Name: "some-shared-security-group", 1039 }, 1040 { 1041 Name: "some-running-security-group", 1042 }, 1043 })) 1044 1045 Expect(fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1046 spaceGUID, queries := fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceArgsForCall(0) 1047 Expect(spaceGUID).To(Equal("space-guid")) 1048 Expect(queries).To(BeNil()) 1049 }) 1050 }) 1051 1052 Context("when the space does not exist", func() { 1053 BeforeEach(func() { 1054 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 1055 nil, 1056 nil, 1057 ccerror.ResourceNotFoundError{}) 1058 }) 1059 1060 It("returns an SpaceNotFoundError", func() { 1061 _, _, err := actor.GetSpaceRunningSecurityGroupsBySpace("space-guid") 1062 Expect(err).To(MatchError(SpaceNotFoundError{GUID: "space-guid"})) 1063 }) 1064 }) 1065 1066 Context("when there is an error", func() { 1067 var expectedErr error 1068 1069 BeforeEach(func() { 1070 expectedErr = errors.New("banana") 1071 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 1072 nil, 1073 ccv2.Warnings{"warning-1", "warning-2"}, 1074 expectedErr) 1075 }) 1076 1077 It("returns the error and warnings", func() { 1078 _, warnings, err := actor.GetSpaceRunningSecurityGroupsBySpace("space-guid") 1079 Expect(warnings).To(ConsistOf([]string{"warning-1", "warning-2"})) 1080 Expect(err).To(MatchError(expectedErr)) 1081 }) 1082 }) 1083 }) 1084 1085 Describe("GetSpaceStagingSecurityGroupsBySpace", func() { 1086 Context("when the space exists and there are no errors", func() { 1087 BeforeEach(func() { 1088 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 1089 []ccv2.SecurityGroup{ 1090 { 1091 Name: "some-shared-security-group", 1092 }, 1093 { 1094 Name: "some-staging-security-group", 1095 }, 1096 }, 1097 ccv2.Warnings{"warning-1", "warning-2"}, 1098 nil, 1099 ) 1100 }) 1101 1102 It("returns the security groups and warnings", func() { 1103 securityGroups, warnings, err := actor.GetSpaceStagingSecurityGroupsBySpace("space-guid") 1104 Expect(err).NotTo(HaveOccurred()) 1105 Expect(warnings).To(ConsistOf([]string{"warning-1", "warning-2"})) 1106 Expect(securityGroups).To(Equal( 1107 []SecurityGroup{ 1108 { 1109 Name: "some-shared-security-group", 1110 }, 1111 { 1112 Name: "some-staging-security-group", 1113 }, 1114 })) 1115 1116 Expect(fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1117 spaceGUID, queries := fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceArgsForCall(0) 1118 Expect(spaceGUID).To(Equal("space-guid")) 1119 Expect(queries).To(BeNil()) 1120 }) 1121 }) 1122 1123 Context("when the space does not exist", func() { 1124 BeforeEach(func() { 1125 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 1126 nil, 1127 nil, 1128 ccerror.ResourceNotFoundError{}) 1129 }) 1130 1131 It("returns an SpaceNotFoundError", func() { 1132 _, _, err := actor.GetSpaceStagingSecurityGroupsBySpace("space-guid") 1133 Expect(err).To(MatchError(SpaceNotFoundError{GUID: "space-guid"})) 1134 }) 1135 }) 1136 1137 Context("when there is an error", func() { 1138 var expectedErr error 1139 1140 BeforeEach(func() { 1141 expectedErr = errors.New("banana") 1142 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 1143 nil, 1144 ccv2.Warnings{"warning-1", "warning-2"}, 1145 expectedErr) 1146 }) 1147 1148 It("returns the error and warnings", func() { 1149 _, warnings, err := actor.GetSpaceStagingSecurityGroupsBySpace("space-guid") 1150 Expect(warnings).To(ConsistOf([]string{"warning-1", "warning-2"})) 1151 Expect(err).To(MatchError(expectedErr)) 1152 }) 1153 }) 1154 }) 1155 1156 Describe("UnbindSecurityGroupByNameAndSpace", func() { 1157 var ( 1158 lifecycle ccv2.SecurityGroupLifecycle 1159 warnings Warnings 1160 err error 1161 ) 1162 1163 JustBeforeEach(func() { 1164 warnings, err = actor.UnbindSecurityGroupByNameAndSpace("some-security-group", "some-space-guid", lifecycle) 1165 }) 1166 1167 Context("when the requested lifecycle is neither running nor staging", func() { 1168 BeforeEach(func() { 1169 lifecycle = "bill & ted" 1170 }) 1171 1172 It("returns and appropriate error", func() { 1173 Expect(err).To(MatchError(fmt.Sprintf("Invalid lifecycle: %s", lifecycle))) 1174 }) 1175 }) 1176 1177 Context("when the security group is not found", func() { 1178 BeforeEach(func() { 1179 lifecycle = ccv2.SecurityGroupLifecycleStaging 1180 1181 fakeCloudControllerClient.GetSecurityGroupsReturns( 1182 []ccv2.SecurityGroup{}, 1183 ccv2.Warnings{"security-group-warning"}, 1184 nil) 1185 }) 1186 1187 It("returns the error and all warnings", func() { 1188 Expect(warnings).To(ConsistOf([]string{"security-group-warning"})) 1189 Expect(err).To(MatchError(SecurityGroupNotFoundError{"some-security-group"})) 1190 }) 1191 }) 1192 1193 Context("when an error is encountered fetching security groups", func() { 1194 var returnedError error 1195 1196 BeforeEach(func() { 1197 lifecycle = ccv2.SecurityGroupLifecycleRunning 1198 1199 returnedError = errors.New("get-security-groups-error") 1200 fakeCloudControllerClient.GetSecurityGroupsReturns( 1201 []ccv2.SecurityGroup{}, 1202 ccv2.Warnings{"warning-1", "warning-2"}, 1203 returnedError) 1204 }) 1205 1206 It("returns all warnings", func() { 1207 Expect(err).To(MatchError(returnedError)) 1208 Expect(warnings).To(ConsistOf(Warnings{"warning-1", "warning-2"})) 1209 }) 1210 }) 1211 1212 Context("when the requested lifecycle is running", func() { 1213 BeforeEach(func() { 1214 lifecycle = ccv2.SecurityGroupLifecycleRunning 1215 1216 fakeCloudControllerClient.GetSecurityGroupsReturns( 1217 []ccv2.SecurityGroup{{ 1218 Name: "some-security-group", 1219 GUID: "some-security-group-guid", 1220 }}, 1221 ccv2.Warnings{"warning-1", "warning-2"}, 1222 nil) 1223 }) 1224 1225 Context("when the security group is bound to running", func() { 1226 BeforeEach(func() { 1227 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 1228 []ccv2.SecurityGroup{ 1229 { 1230 Name: "some-security-group", 1231 GUID: "some-security-group-guid", 1232 }, 1233 }, 1234 ccv2.Warnings{"warning-3", "warning-4"}, 1235 nil, 1236 ) 1237 }) 1238 1239 Context("when an error is encountered checking whether the security group is bound to the space in the running phase", func() { 1240 var returnedError error 1241 1242 BeforeEach(func() { 1243 returnedError = errors.New("get-security-groups-error") 1244 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 1245 []ccv2.SecurityGroup{ 1246 { 1247 Name: "some-security-group", 1248 GUID: "some-security-group-guid", 1249 }, 1250 }, 1251 ccv2.Warnings{"warning-3", "warning-4"}, 1252 returnedError, 1253 ) 1254 }) 1255 1256 It("returns all warnings", func() { 1257 Expect(err).To(MatchError(returnedError)) 1258 Expect(warnings).To(ConsistOf(Warnings{"warning-1", "warning-2", "warning-3", "warning-4"})) 1259 }) 1260 }) 1261 1262 Context("when an error is encountered unbinding the security group from the space", func() { 1263 var returnedError error 1264 1265 BeforeEach(func() { 1266 returnedError = errors.New("associate-space-error") 1267 fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupReturns( 1268 ccv2.Warnings{"warning-5", "warning-6"}, 1269 returnedError) 1270 }) 1271 1272 It("returns the error and all warnings", func() { 1273 Expect(warnings).To(ConsistOf([]string{ 1274 "warning-1", 1275 "warning-2", 1276 "warning-3", 1277 "warning-4", 1278 "warning-5", 1279 "warning-6", 1280 })) 1281 Expect(err).To(MatchError(returnedError)) 1282 }) 1283 }) 1284 1285 Context("when no errors are encountered", func() { 1286 BeforeEach(func() { 1287 fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupReturns( 1288 ccv2.Warnings{"warning-5", "warning-6"}, 1289 nil) 1290 }) 1291 1292 It("returns all warnings", func() { 1293 Expect(warnings).To(ConsistOf([]string{ 1294 "warning-1", 1295 "warning-2", 1296 "warning-3", 1297 "warning-4", 1298 "warning-5", 1299 "warning-6", 1300 })) 1301 Expect(err).ToNot(HaveOccurred()) 1302 1303 Expect(fakeCloudControllerClient.GetSecurityGroupsCallCount()).To(Equal(1)) 1304 Expect(fakeCloudControllerClient.GetSecurityGroupsArgsForCall(0)).To(Equal([]ccv2.Query{{ 1305 Filter: ccv2.NameFilter, 1306 Operator: ccv2.EqualOperator, 1307 Value: "some-security-group", 1308 }})) 1309 1310 Expect(fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1311 spaceGUID, queries := fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceArgsForCall(0) 1312 Expect(spaceGUID).To(Equal("some-space-guid")) 1313 Expect(queries).To(Equal([]ccv2.Query{{ 1314 Filter: ccv2.NameFilter, 1315 Operator: ccv2.EqualOperator, 1316 Value: "some-security-group", 1317 }})) 1318 1319 Expect(fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceCallCount()).To(Equal(0)) 1320 1321 Expect(fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupCallCount()).To(Equal(1)) 1322 securityGroupGUID, spaceGUID := fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupArgsForCall(0) 1323 Expect(securityGroupGUID).To(Equal("some-security-group-guid")) 1324 Expect(spaceGUID).To(Equal("some-space-guid")) 1325 1326 Expect(fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupCallCount()).To(Equal(0)) 1327 }) 1328 }) 1329 }) 1330 1331 Context("when the security group is bound to neither running nor staging", func() { 1332 BeforeEach(func() { 1333 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 1334 []ccv2.SecurityGroup{}, 1335 ccv2.Warnings{"warning-3", "warning-4"}, 1336 nil, 1337 ) 1338 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 1339 []ccv2.SecurityGroup{}, 1340 ccv2.Warnings{"warning-5", "warning-6"}, 1341 nil, 1342 ) 1343 }) 1344 1345 Context("when no errors are encountered", func() { 1346 It("returns all warnings", func() { 1347 Expect(warnings).To(ConsistOf([]string{ 1348 "warning-1", 1349 "warning-2", 1350 "warning-3", 1351 "warning-4", 1352 "warning-5", 1353 "warning-6", 1354 })) 1355 Expect(err).ToNot(HaveOccurred()) 1356 1357 Expect(fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1358 spaceGUIDRunning, queriesRunning := fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceArgsForCall(0) 1359 Expect(spaceGUIDRunning).To(Equal("some-space-guid")) 1360 Expect(queriesRunning).To(Equal([]ccv2.Query{{ 1361 Filter: ccv2.NameFilter, 1362 Operator: ccv2.EqualOperator, 1363 Value: "some-security-group", 1364 }})) 1365 1366 Expect(fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1367 spaceGUIDStaging, queriesStaging := fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceArgsForCall(0) 1368 Expect(spaceGUIDStaging).To(Equal("some-space-guid")) 1369 Expect(queriesStaging).To(Equal([]ccv2.Query{{ 1370 Filter: ccv2.NameFilter, 1371 Operator: ccv2.EqualOperator, 1372 Value: "some-security-group", 1373 }})) 1374 1375 Expect(fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupCallCount()).To(Equal(0)) 1376 Expect(fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupCallCount()).To(Equal(0)) 1377 }) 1378 }) 1379 }) 1380 1381 Context("when the security group is bound to staging", func() { 1382 BeforeEach(func() { 1383 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 1384 []ccv2.SecurityGroup{}, 1385 ccv2.Warnings{"warning-3", "warning-4"}, 1386 nil, 1387 ) 1388 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 1389 []ccv2.SecurityGroup{ 1390 { 1391 Name: "some-security-group", 1392 GUID: "some-security-group-guid", 1393 }, 1394 }, 1395 ccv2.Warnings{"warning-5", "warning-6"}, 1396 nil, 1397 ) 1398 }) 1399 1400 It("returns all warnings and a SecurityGroupNotBoundError", func() { 1401 Expect(warnings).To(ConsistOf([]string{ 1402 "warning-1", 1403 "warning-2", 1404 "warning-3", 1405 "warning-4", 1406 "warning-5", 1407 "warning-6", 1408 })) 1409 Expect(err).To(MatchError(SecurityGroupNotBoundError{ 1410 Name: "some-security-group", 1411 Lifecycle: lifecycle, 1412 })) 1413 1414 Expect(fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1415 spaceGUIDRunning, queriesRunning := fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceArgsForCall(0) 1416 Expect(spaceGUIDRunning).To(Equal("some-space-guid")) 1417 Expect(queriesRunning).To(Equal([]ccv2.Query{{ 1418 Filter: ccv2.NameFilter, 1419 Operator: ccv2.EqualOperator, 1420 Value: "some-security-group", 1421 }})) 1422 1423 Expect(fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1424 spaceGUIDStaging, queriesStaging := fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceArgsForCall(0) 1425 Expect(spaceGUIDStaging).To(Equal("some-space-guid")) 1426 Expect(queriesStaging).To(Equal([]ccv2.Query{{ 1427 Filter: ccv2.NameFilter, 1428 Operator: ccv2.EqualOperator, 1429 Value: "some-security-group", 1430 }})) 1431 1432 Expect(fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupCallCount()).To(Equal(0)) 1433 Expect(fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupCallCount()).To(Equal(0)) 1434 }) 1435 }) 1436 }) 1437 1438 Context("when the requested lifecycle is staging", func() { 1439 BeforeEach(func() { 1440 lifecycle = ccv2.SecurityGroupLifecycleStaging 1441 1442 fakeCloudControllerClient.GetSecurityGroupsReturns( 1443 []ccv2.SecurityGroup{{ 1444 Name: "some-security-group", 1445 GUID: "some-security-group-guid", 1446 }}, 1447 ccv2.Warnings{"warning-1", "warning-2"}, 1448 nil) 1449 }) 1450 1451 Context("when an error is encountered checking whether the security group is bound to the space in the staging phase", func() { 1452 var returnedError error 1453 1454 BeforeEach(func() { 1455 returnedError = errors.New("get-space-staging-security-groups-error") 1456 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 1457 []ccv2.SecurityGroup{}, 1458 ccv2.Warnings{"warning-3", "warning-4"}, 1459 returnedError, 1460 ) 1461 }) 1462 1463 It("returns all warnings", func() { 1464 Expect(err).To(MatchError(returnedError)) 1465 Expect(warnings).To(ConsistOf(Warnings{"warning-1", "warning-2", "warning-3", "warning-4"})) 1466 }) 1467 }) 1468 1469 Context("when the security group is bound to staging", func() { 1470 BeforeEach(func() { 1471 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 1472 []ccv2.SecurityGroup{ 1473 { 1474 Name: "some-security-group", 1475 GUID: "some-security-group-guid", 1476 }, 1477 }, 1478 ccv2.Warnings{"warning-3", "warning-4"}, 1479 nil, 1480 ) 1481 }) 1482 1483 Context("when an error is encountered unbinding the security group the space", func() { 1484 var returnedError error 1485 1486 BeforeEach(func() { 1487 returnedError = errors.New("associate-space-error") 1488 fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupReturns( 1489 ccv2.Warnings{"warning-5", "warning-6"}, 1490 returnedError) 1491 }) 1492 1493 It("returns the error and all warnings", func() { 1494 Expect(err).To(MatchError(returnedError)) 1495 Expect(warnings).To(ConsistOf([]string{ 1496 "warning-1", 1497 "warning-2", 1498 "warning-3", 1499 "warning-4", 1500 "warning-5", 1501 "warning-6", 1502 })) 1503 }) 1504 }) 1505 1506 Context("when no errors are encountered", func() { 1507 BeforeEach(func() { 1508 fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupReturns( 1509 ccv2.Warnings{"warning-5", "warning-6"}, 1510 nil) 1511 }) 1512 1513 It("unbinds and returns all warnings", func() { 1514 Expect(err).ToNot(HaveOccurred()) 1515 Expect(warnings).To(ConsistOf([]string{ 1516 "warning-1", 1517 "warning-2", 1518 "warning-3", 1519 "warning-4", 1520 "warning-5", 1521 "warning-6", 1522 })) 1523 1524 Expect(fakeCloudControllerClient.GetSecurityGroupsCallCount()).To(Equal(1)) 1525 Expect(fakeCloudControllerClient.GetSecurityGroupsArgsForCall(0)).To(Equal([]ccv2.Query{{ 1526 Filter: ccv2.NameFilter, 1527 Operator: ccv2.EqualOperator, 1528 Value: "some-security-group", 1529 }})) 1530 1531 Expect(fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1532 spaceGUID, queries := fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceArgsForCall(0) 1533 Expect(spaceGUID).To(Equal("some-space-guid")) 1534 Expect(queries).To(Equal([]ccv2.Query{{ 1535 Filter: ccv2.NameFilter, 1536 Operator: ccv2.EqualOperator, 1537 Value: "some-security-group", 1538 }})) 1539 1540 Expect(fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceCallCount()).To(Equal(0)) 1541 1542 Expect(fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupCallCount()).To(Equal(1)) 1543 securityGroupGUID, spaceGUID := fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupArgsForCall(0) 1544 Expect(securityGroupGUID).To(Equal("some-security-group-guid")) 1545 Expect(spaceGUID).To(Equal("some-space-guid")) 1546 1547 Expect(fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupCallCount()).To(Equal(0)) 1548 }) 1549 }) 1550 }) 1551 1552 Context("when the security group is bound to neither running nor staging", func() { 1553 BeforeEach(func() { 1554 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 1555 []ccv2.SecurityGroup{}, 1556 ccv2.Warnings{"warning-3", "warning-4"}, 1557 nil, 1558 ) 1559 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 1560 []ccv2.SecurityGroup{}, 1561 ccv2.Warnings{"warning-5", "warning-6"}, 1562 nil, 1563 ) 1564 }) 1565 1566 Context("when no errors are encountered", func() { 1567 It("returns all warnings", func() { 1568 Expect(err).ToNot(HaveOccurred()) 1569 Expect(warnings).To(ConsistOf([]string{ 1570 "warning-1", 1571 "warning-2", 1572 "warning-3", 1573 "warning-4", 1574 "warning-5", 1575 "warning-6", 1576 })) 1577 1578 Expect(fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1579 spaceGUIDStaging, queriesStaging := fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceArgsForCall(0) 1580 Expect(spaceGUIDStaging).To(Equal("some-space-guid")) 1581 Expect(queriesStaging).To(Equal([]ccv2.Query{{ 1582 Filter: ccv2.NameFilter, 1583 Operator: ccv2.EqualOperator, 1584 Value: "some-security-group", 1585 }})) 1586 1587 Expect(fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1588 spaceGUIDRunning, queriesRunning := fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceArgsForCall(0) 1589 Expect(spaceGUIDRunning).To(Equal("some-space-guid")) 1590 Expect(queriesRunning).To(Equal([]ccv2.Query{{ 1591 Filter: ccv2.NameFilter, 1592 Operator: ccv2.EqualOperator, 1593 Value: "some-security-group", 1594 }})) 1595 1596 Expect(fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupCallCount()).To(Equal(0)) 1597 Expect(fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupCallCount()).To(Equal(0)) 1598 }) 1599 }) 1600 }) 1601 1602 Context("when the security group is bound to running", func() { 1603 BeforeEach(func() { 1604 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 1605 []ccv2.SecurityGroup{}, 1606 ccv2.Warnings{"warning-3", "warning-4"}, 1607 nil, 1608 ) 1609 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 1610 []ccv2.SecurityGroup{ 1611 { 1612 Name: "some-security-group", 1613 GUID: "some-security-group-guid", 1614 }, 1615 }, 1616 ccv2.Warnings{"warning-5", "warning-6"}, 1617 nil, 1618 ) 1619 }) 1620 1621 It("returns all warnings and a SecurityGroupNotBoundError", func() { 1622 Expect(warnings).To(ConsistOf([]string{ 1623 "warning-1", 1624 "warning-2", 1625 "warning-3", 1626 "warning-4", 1627 "warning-5", 1628 "warning-6", 1629 })) 1630 1631 Expect(err).To(MatchError(SecurityGroupNotBoundError{ 1632 Name: "some-security-group", 1633 Lifecycle: lifecycle, 1634 })) 1635 1636 Expect(fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1637 spaceGUIDStaging, queriesStaging := fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceArgsForCall(0) 1638 Expect(spaceGUIDStaging).To(Equal("some-space-guid")) 1639 Expect(queriesStaging).To(Equal([]ccv2.Query{{ 1640 Filter: ccv2.NameFilter, 1641 Operator: ccv2.EqualOperator, 1642 Value: "some-security-group", 1643 }})) 1644 1645 Expect(fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1646 spaceGUIDRunning, queriesRunning := fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceArgsForCall(0) 1647 Expect(spaceGUIDRunning).To(Equal("some-space-guid")) 1648 Expect(queriesRunning).To(Equal([]ccv2.Query{{ 1649 Filter: ccv2.NameFilter, 1650 Operator: ccv2.EqualOperator, 1651 Value: "some-security-group", 1652 }})) 1653 1654 Expect(fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupCallCount()).To(Equal(0)) 1655 Expect(fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupCallCount()).To(Equal(0)) 1656 }) 1657 }) 1658 1659 Context("when it is not bound to staging and an error occurs checking whether bound to running", func() { 1660 var returnedError error 1661 1662 BeforeEach(func() { 1663 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 1664 []ccv2.SecurityGroup{}, 1665 ccv2.Warnings{"warning-3", "warning-4"}, 1666 nil, 1667 ) 1668 returnedError = errors.New("get-space-running-security-groups-error") 1669 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 1670 []ccv2.SecurityGroup{ 1671 { 1672 Name: "some-security-group", 1673 GUID: "some-security-group-guid", 1674 }, 1675 }, 1676 ccv2.Warnings{"warning-5", "warning-6"}, 1677 returnedError, 1678 ) 1679 }) 1680 1681 It("returns all warnings", func() { 1682 Expect(err).To(MatchError(returnedError)) 1683 Expect(warnings).To(ConsistOf(Warnings{"warning-1", "warning-2", "warning-3", "warning-4", "warning-5", "warning-6"})) 1684 }) 1685 }) 1686 }) 1687 }) 1688 1689 Describe("UnbindSecurityGroupByNameOrganizationNameAndSpaceName", func() { 1690 var ( 1691 lifecycle ccv2.SecurityGroupLifecycle 1692 warnings []string 1693 err error 1694 ) 1695 1696 JustBeforeEach(func() { 1697 warnings, err = actor.UnbindSecurityGroupByNameOrganizationNameAndSpaceName("some-security-group", "some-org", "some-space", lifecycle) 1698 }) 1699 1700 Context("when the requested lifecycle is neither running nor staging", func() { 1701 BeforeEach(func() { 1702 lifecycle = "bill & ted" 1703 }) 1704 1705 It("returns and appropriate error", func() { 1706 Expect(err).To(MatchError(fmt.Sprintf("Invalid lifecycle: %s", lifecycle))) 1707 }) 1708 }) 1709 1710 Context("when the security group is not found", func() { 1711 BeforeEach(func() { 1712 lifecycle = ccv2.SecurityGroupLifecycleRunning 1713 1714 fakeCloudControllerClient.GetSecurityGroupsReturns( 1715 []ccv2.SecurityGroup{}, 1716 ccv2.Warnings{"security-group-warning"}, 1717 nil) 1718 }) 1719 1720 It("returns the error and all warnings", func() { 1721 Expect(warnings).To(ConsistOf([]string{"security-group-warning"})) 1722 Expect(err).To(MatchError(SecurityGroupNotFoundError{"some-security-group"})) 1723 }) 1724 }) 1725 1726 Context("when an error is encountered getting the organization", func() { 1727 BeforeEach(func() { 1728 lifecycle = ccv2.SecurityGroupLifecycleRunning 1729 1730 fakeCloudControllerClient.GetSecurityGroupsReturns( 1731 []ccv2.SecurityGroup{{ 1732 Name: "some-security-group", 1733 GUID: "some-security-group-guid", 1734 }}, 1735 ccv2.Warnings{"security-group-warning"}, 1736 nil) 1737 fakeCloudControllerClient.GetOrganizationsReturns( 1738 []ccv2.Organization{}, 1739 ccv2.Warnings{"org-warning"}, 1740 nil) 1741 }) 1742 1743 It("returns the error and all warnings", func() { 1744 Expect(warnings).To(ConsistOf([]string{"security-group-warning", "org-warning"})) 1745 Expect(err).To(MatchError(OrganizationNotFoundError{Name: "some-org"})) 1746 }) 1747 }) 1748 1749 Context("when an error is encountered getting the space", func() { 1750 BeforeEach(func() { 1751 lifecycle = ccv2.SecurityGroupLifecycleRunning 1752 1753 fakeCloudControllerClient.GetSecurityGroupsReturns( 1754 []ccv2.SecurityGroup{{ 1755 Name: "some-security-group", 1756 GUID: "some-security-group-guid", 1757 }}, 1758 ccv2.Warnings{"security-group-warning"}, 1759 nil) 1760 fakeCloudControllerClient.GetOrganizationsReturns( 1761 []ccv2.Organization{{ 1762 Name: "some-org", 1763 GUID: "some-org-guid", 1764 }}, 1765 ccv2.Warnings{"org-warning"}, 1766 nil) 1767 fakeCloudControllerClient.GetSpacesReturns( 1768 []ccv2.Space{}, 1769 ccv2.Warnings{"space-warning"}, 1770 nil) 1771 }) 1772 1773 It("returns the error and all warnings", func() { 1774 Expect(warnings).To(ConsistOf([]string{"security-group-warning", "org-warning", "space-warning"})) 1775 Expect(err).To(MatchError(SpaceNotFoundError{Name: "some-space"})) 1776 }) 1777 }) 1778 1779 Context("when the requested lifecycle is running", func() { 1780 BeforeEach(func() { 1781 lifecycle = ccv2.SecurityGroupLifecycleRunning 1782 1783 fakeCloudControllerClient.GetSecurityGroupsReturns( 1784 []ccv2.SecurityGroup{{ 1785 Name: "some-security-group", 1786 GUID: "some-security-group-guid", 1787 }}, 1788 ccv2.Warnings{"warning-1", "warning-2"}, 1789 nil) 1790 fakeCloudControllerClient.GetOrganizationsReturns( 1791 []ccv2.Organization{{ 1792 Name: "some-org", 1793 GUID: "some-org-guid", 1794 }}, 1795 ccv2.Warnings{"warning-3", "warning-4"}, 1796 nil) 1797 fakeCloudControllerClient.GetSpacesReturns( 1798 []ccv2.Space{{ 1799 Name: "some-space", 1800 GUID: "some-space-guid", 1801 }}, 1802 ccv2.Warnings{"warning-5", "warning-6"}, 1803 nil) 1804 }) 1805 1806 Context("when the security group is bound to running", func() { 1807 BeforeEach(func() { 1808 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 1809 []ccv2.SecurityGroup{ 1810 { 1811 Name: "some-security-group", 1812 GUID: "some-security-group-guid", 1813 }, 1814 }, 1815 ccv2.Warnings{"warning-7", "warning-8"}, 1816 nil, 1817 ) 1818 }) 1819 1820 Context("when an error is encountered unbinding the security group from the space", func() { 1821 var returnedError error 1822 1823 BeforeEach(func() { 1824 returnedError = errors.New("associate-space-error") 1825 fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupReturns( 1826 ccv2.Warnings{"warning-9", "warning-10"}, 1827 returnedError) 1828 }) 1829 1830 It("returns the error and all warnings", func() { 1831 Expect(warnings).To(ConsistOf([]string{ 1832 "warning-1", 1833 "warning-2", 1834 "warning-3", 1835 "warning-4", 1836 "warning-5", 1837 "warning-6", 1838 "warning-7", 1839 "warning-8", 1840 "warning-9", 1841 "warning-10", 1842 })) 1843 Expect(err).To(MatchError(returnedError)) 1844 }) 1845 }) 1846 1847 Context("when no errors are encountered", func() { 1848 BeforeEach(func() { 1849 fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupReturns( 1850 ccv2.Warnings{"warning-9", "warning-10"}, 1851 nil) 1852 }) 1853 1854 It("returns all warnings", func() { 1855 Expect(warnings).To(ConsistOf([]string{ 1856 "warning-1", 1857 "warning-2", 1858 "warning-3", 1859 "warning-4", 1860 "warning-5", 1861 "warning-6", 1862 "warning-7", 1863 "warning-8", 1864 "warning-9", 1865 "warning-10", 1866 })) 1867 Expect(err).ToNot(HaveOccurred()) 1868 1869 Expect(fakeCloudControllerClient.GetSecurityGroupsCallCount()).To(Equal(1)) 1870 Expect(fakeCloudControllerClient.GetSecurityGroupsArgsForCall(0)).To(Equal([]ccv2.Query{{ 1871 Filter: ccv2.NameFilter, 1872 Operator: ccv2.EqualOperator, 1873 Value: "some-security-group", 1874 }})) 1875 1876 Expect(fakeCloudControllerClient.GetOrganizationsCallCount()).To(Equal(1)) 1877 Expect(fakeCloudControllerClient.GetOrganizationsArgsForCall(0)).To(Equal([]ccv2.Query{{ 1878 Filter: ccv2.NameFilter, 1879 Operator: ccv2.EqualOperator, 1880 Value: "some-org", 1881 }})) 1882 1883 Expect(fakeCloudControllerClient.GetSpacesCallCount()).To(Equal(1)) 1884 Expect(fakeCloudControllerClient.GetSpacesArgsForCall(0)).To(Equal([]ccv2.Query{{ 1885 Filter: ccv2.NameFilter, 1886 Operator: ccv2.EqualOperator, 1887 Value: "some-space", 1888 }, { 1889 Filter: ccv2.OrganizationGUIDFilter, 1890 Operator: ccv2.EqualOperator, 1891 Value: "some-org-guid", 1892 }})) 1893 1894 Expect(fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1895 spaceGUID, queries := fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceArgsForCall(0) 1896 Expect(spaceGUID).To(Equal("some-space-guid")) 1897 Expect(queries).To(Equal([]ccv2.Query{{ 1898 Filter: ccv2.NameFilter, 1899 Operator: ccv2.EqualOperator, 1900 Value: "some-security-group", 1901 }})) 1902 1903 Expect(fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceCallCount()).To(Equal(0)) 1904 1905 Expect(fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupCallCount()).To(Equal(1)) 1906 securityGroupGUID, spaceGUID := fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupArgsForCall(0) 1907 Expect(securityGroupGUID).To(Equal("some-security-group-guid")) 1908 Expect(spaceGUID).To(Equal("some-space-guid")) 1909 1910 Expect(fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupCallCount()).To(Equal(0)) 1911 }) 1912 }) 1913 }) 1914 1915 Context("when the security group is bound to neither running nor staging", func() { 1916 BeforeEach(func() { 1917 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 1918 []ccv2.SecurityGroup{}, 1919 ccv2.Warnings{"warning-7", "warning-8"}, 1920 nil, 1921 ) 1922 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 1923 []ccv2.SecurityGroup{}, 1924 ccv2.Warnings{"warning-9", "warning-10"}, 1925 nil, 1926 ) 1927 }) 1928 1929 Context("when no errors are encountered", func() { 1930 It("returns all warnings", func() { 1931 Expect(warnings).To(ConsistOf([]string{ 1932 "warning-1", 1933 "warning-2", 1934 "warning-3", 1935 "warning-4", 1936 "warning-5", 1937 "warning-6", 1938 "warning-7", 1939 "warning-8", 1940 "warning-9", 1941 "warning-10", 1942 })) 1943 Expect(err).ToNot(HaveOccurred()) 1944 1945 Expect(fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1946 spaceGUIDRunning, queriesRunning := fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceArgsForCall(0) 1947 Expect(spaceGUIDRunning).To(Equal("some-space-guid")) 1948 Expect(queriesRunning).To(Equal([]ccv2.Query{{ 1949 Filter: ccv2.NameFilter, 1950 Operator: ccv2.EqualOperator, 1951 Value: "some-security-group", 1952 }})) 1953 1954 Expect(fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceCallCount()).To(Equal(1)) 1955 spaceGUIDStaging, queriesStaging := fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceArgsForCall(0) 1956 Expect(spaceGUIDStaging).To(Equal("some-space-guid")) 1957 Expect(queriesStaging).To(Equal([]ccv2.Query{{ 1958 Filter: ccv2.NameFilter, 1959 Operator: ccv2.EqualOperator, 1960 Value: "some-security-group", 1961 }})) 1962 1963 Expect(fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupCallCount()).To(Equal(0)) 1964 Expect(fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupCallCount()).To(Equal(0)) 1965 }) 1966 }) 1967 }) 1968 1969 Context("when the security group is bound to staging", func() { 1970 BeforeEach(func() { 1971 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 1972 []ccv2.SecurityGroup{}, 1973 ccv2.Warnings{"warning-7", "warning-8"}, 1974 nil, 1975 ) 1976 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 1977 []ccv2.SecurityGroup{ 1978 { 1979 Name: "some-security-group", 1980 GUID: "some-security-group-guid", 1981 }, 1982 }, 1983 ccv2.Warnings{"warning-9", "warning-10"}, 1984 nil, 1985 ) 1986 }) 1987 1988 It("returns all warnings and a SecurityGroupNotBoundError", func() { 1989 Expect(warnings).To(ConsistOf([]string{ 1990 "warning-1", 1991 "warning-2", 1992 "warning-3", 1993 "warning-4", 1994 "warning-5", 1995 "warning-6", 1996 "warning-7", 1997 "warning-8", 1998 "warning-9", 1999 "warning-10", 2000 })) 2001 Expect(err).To(MatchError(SecurityGroupNotBoundError{ 2002 Name: "some-security-group", 2003 Lifecycle: lifecycle, 2004 })) 2005 2006 Expect(fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceCallCount()).To(Equal(1)) 2007 spaceGUIDRunning, queriesRunning := fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceArgsForCall(0) 2008 Expect(spaceGUIDRunning).To(Equal("some-space-guid")) 2009 Expect(queriesRunning).To(Equal([]ccv2.Query{{ 2010 Filter: ccv2.NameFilter, 2011 Operator: ccv2.EqualOperator, 2012 Value: "some-security-group", 2013 }})) 2014 2015 Expect(fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceCallCount()).To(Equal(1)) 2016 spaceGUIDStaging, queriesStaging := fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceArgsForCall(0) 2017 Expect(spaceGUIDStaging).To(Equal("some-space-guid")) 2018 Expect(queriesStaging).To(Equal([]ccv2.Query{{ 2019 Filter: ccv2.NameFilter, 2020 Operator: ccv2.EqualOperator, 2021 Value: "some-security-group", 2022 }})) 2023 2024 Expect(fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupCallCount()).To(Equal(0)) 2025 Expect(fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupCallCount()).To(Equal(0)) 2026 }) 2027 }) 2028 }) 2029 2030 Context("when the requested lifecycle is staging", func() { 2031 BeforeEach(func() { 2032 lifecycle = ccv2.SecurityGroupLifecycleStaging 2033 2034 fakeCloudControllerClient.GetSecurityGroupsReturns( 2035 []ccv2.SecurityGroup{{ 2036 Name: "some-security-group", 2037 GUID: "some-security-group-guid", 2038 }}, 2039 ccv2.Warnings{"warning-1", "warning-2"}, 2040 nil) 2041 fakeCloudControllerClient.GetOrganizationsReturns( 2042 []ccv2.Organization{{ 2043 Name: "some-org", 2044 GUID: "some-org-guid", 2045 }}, 2046 ccv2.Warnings{"warning-3", "warning-4"}, 2047 nil) 2048 fakeCloudControllerClient.GetSpacesReturns( 2049 []ccv2.Space{{ 2050 Name: "some-space", 2051 GUID: "some-space-guid", 2052 }}, 2053 ccv2.Warnings{"warning-5", "warning-6"}, 2054 nil) 2055 }) 2056 2057 Context("when the security group is bound to staging", func() { 2058 BeforeEach(func() { 2059 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 2060 []ccv2.SecurityGroup{ 2061 { 2062 Name: "some-security-group", 2063 GUID: "some-security-group-guid", 2064 }, 2065 }, 2066 ccv2.Warnings{"warning-7", "warning-8"}, 2067 nil, 2068 ) 2069 }) 2070 2071 Context("when an error is encountered unbinding the security group the space", func() { 2072 var returnedError error 2073 2074 BeforeEach(func() { 2075 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 2076 []ccv2.SecurityGroup{ 2077 { 2078 Name: "some-security-group", 2079 GUID: "some-security-group-guid", 2080 }, 2081 }, 2082 ccv2.Warnings{"warning-7", "warning-8"}, 2083 nil, 2084 ) 2085 returnedError = errors.New("associate-space-error") 2086 fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupReturns( 2087 ccv2.Warnings{"warning-9", "warning-10"}, 2088 returnedError) 2089 }) 2090 2091 It("returns the error and all warnings", func() { 2092 Expect(warnings).To(ConsistOf([]string{ 2093 "warning-1", 2094 "warning-2", 2095 "warning-3", 2096 "warning-4", 2097 "warning-5", 2098 "warning-6", 2099 "warning-7", 2100 "warning-8", 2101 "warning-9", 2102 "warning-10", 2103 })) 2104 Expect(err).To(MatchError(returnedError)) 2105 }) 2106 }) 2107 2108 Context("when no errors are encountered", func() { 2109 BeforeEach(func() { 2110 fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupReturns( 2111 ccv2.Warnings{"warning-9", "warning-10"}, 2112 nil) 2113 }) 2114 2115 It("returns all warnings", func() { 2116 Expect(err).ToNot(HaveOccurred()) 2117 Expect(warnings).To(ConsistOf([]string{ 2118 "warning-1", 2119 "warning-2", 2120 "warning-3", 2121 "warning-4", 2122 "warning-5", 2123 "warning-6", 2124 "warning-7", 2125 "warning-8", 2126 "warning-9", 2127 "warning-10", 2128 })) 2129 2130 Expect(fakeCloudControllerClient.GetSecurityGroupsCallCount()).To(Equal(1)) 2131 Expect(fakeCloudControllerClient.GetSecurityGroupsArgsForCall(0)).To(Equal([]ccv2.Query{{ 2132 Filter: ccv2.NameFilter, 2133 Operator: ccv2.EqualOperator, 2134 Value: "some-security-group", 2135 }})) 2136 2137 Expect(fakeCloudControllerClient.GetOrganizationsCallCount()).To(Equal(1)) 2138 Expect(fakeCloudControllerClient.GetOrganizationsArgsForCall(0)).To(Equal([]ccv2.Query{{ 2139 Filter: ccv2.NameFilter, 2140 Operator: ccv2.EqualOperator, 2141 Value: "some-org", 2142 }})) 2143 2144 Expect(fakeCloudControllerClient.GetSpacesCallCount()).To(Equal(1)) 2145 Expect(fakeCloudControllerClient.GetSpacesArgsForCall(0)).To(Equal([]ccv2.Query{{ 2146 Filter: ccv2.NameFilter, 2147 Operator: ccv2.EqualOperator, 2148 Value: "some-space", 2149 }, { 2150 Filter: ccv2.OrganizationGUIDFilter, 2151 Operator: ccv2.EqualOperator, 2152 Value: "some-org-guid", 2153 }})) 2154 2155 Expect(fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceCallCount()).To(Equal(1)) 2156 spaceGUID, queries := fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceArgsForCall(0) 2157 Expect(spaceGUID).To(Equal("some-space-guid")) 2158 Expect(queries).To(Equal([]ccv2.Query{{ 2159 Filter: ccv2.NameFilter, 2160 Operator: ccv2.EqualOperator, 2161 Value: "some-security-group", 2162 }})) 2163 2164 Expect(fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceCallCount()).To(Equal(0)) 2165 2166 Expect(fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupCallCount()).To(Equal(1)) 2167 securityGroupGUID, spaceGUID := fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupArgsForCall(0) 2168 Expect(securityGroupGUID).To(Equal("some-security-group-guid")) 2169 Expect(spaceGUID).To(Equal("some-space-guid")) 2170 2171 Expect(fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupCallCount()).To(Equal(0)) 2172 }) 2173 }) 2174 }) 2175 2176 Context("when the security group is bound to neither running nor staging", func() { 2177 BeforeEach(func() { 2178 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 2179 []ccv2.SecurityGroup{}, 2180 ccv2.Warnings{"warning-7", "warning-8"}, 2181 nil, 2182 ) 2183 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 2184 []ccv2.SecurityGroup{}, 2185 ccv2.Warnings{"warning-9", "warning-10"}, 2186 nil, 2187 ) 2188 }) 2189 2190 Context("when no errors are encountered", func() { 2191 It("returns all warnings", func() { 2192 Expect(err).ToNot(HaveOccurred()) 2193 Expect(warnings).To(ConsistOf([]string{ 2194 "warning-1", 2195 "warning-2", 2196 "warning-3", 2197 "warning-4", 2198 "warning-5", 2199 "warning-6", 2200 "warning-7", 2201 "warning-8", 2202 "warning-9", 2203 "warning-10", 2204 })) 2205 2206 Expect(fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceCallCount()).To(Equal(1)) 2207 spaceGUIDStaging, queriesStaging := fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceArgsForCall(0) 2208 Expect(spaceGUIDStaging).To(Equal("some-space-guid")) 2209 Expect(queriesStaging).To(Equal([]ccv2.Query{{ 2210 Filter: ccv2.NameFilter, 2211 Operator: ccv2.EqualOperator, 2212 Value: "some-security-group", 2213 }})) 2214 2215 Expect(fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceCallCount()).To(Equal(1)) 2216 spaceGUIDRunning, queriesRunning := fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceArgsForCall(0) 2217 Expect(spaceGUIDRunning).To(Equal("some-space-guid")) 2218 Expect(queriesRunning).To(Equal([]ccv2.Query{{ 2219 Filter: ccv2.NameFilter, 2220 Operator: ccv2.EqualOperator, 2221 Value: "some-security-group", 2222 }})) 2223 2224 Expect(fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupCallCount()).To(Equal(0)) 2225 Expect(fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupCallCount()).To(Equal(0)) 2226 }) 2227 }) 2228 }) 2229 2230 Context("when the security group is bound to running", func() { 2231 BeforeEach(func() { 2232 fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceReturns( 2233 []ccv2.SecurityGroup{}, 2234 ccv2.Warnings{"warning-7", "warning-8"}, 2235 nil, 2236 ) 2237 fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceReturns( 2238 []ccv2.SecurityGroup{ 2239 { 2240 Name: "some-security-group", 2241 GUID: "some-security-group-guid", 2242 }, 2243 }, 2244 ccv2.Warnings{"warning-9", "warning-10"}, 2245 nil, 2246 ) 2247 }) 2248 2249 It("returns all warnings and a SecurityGroupNotBoundError", func() { 2250 Expect(warnings).To(ConsistOf([]string{ 2251 "warning-1", 2252 "warning-2", 2253 "warning-3", 2254 "warning-4", 2255 "warning-5", 2256 "warning-6", 2257 "warning-7", 2258 "warning-8", 2259 "warning-9", 2260 "warning-10", 2261 })) 2262 2263 Expect(err).To(MatchError(SecurityGroupNotBoundError{ 2264 Name: "some-security-group", 2265 Lifecycle: lifecycle, 2266 })) 2267 2268 Expect(fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceCallCount()).To(Equal(1)) 2269 spaceGUIDStaging, queriesStaging := fakeCloudControllerClient.GetSpaceStagingSecurityGroupsBySpaceArgsForCall(0) 2270 Expect(spaceGUIDStaging).To(Equal("some-space-guid")) 2271 Expect(queriesStaging).To(Equal([]ccv2.Query{{ 2272 Filter: ccv2.NameFilter, 2273 Operator: ccv2.EqualOperator, 2274 Value: "some-security-group", 2275 }})) 2276 2277 Expect(fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceCallCount()).To(Equal(1)) 2278 spaceGUIDRunning, queriesRunning := fakeCloudControllerClient.GetSpaceRunningSecurityGroupsBySpaceArgsForCall(0) 2279 Expect(spaceGUIDRunning).To(Equal("some-space-guid")) 2280 Expect(queriesRunning).To(Equal([]ccv2.Query{{ 2281 Filter: ccv2.NameFilter, 2282 Operator: ccv2.EqualOperator, 2283 Value: "some-security-group", 2284 }})) 2285 2286 Expect(fakeCloudControllerClient.RemoveSpaceFromStagingSecurityGroupCallCount()).To(Equal(0)) 2287 Expect(fakeCloudControllerClient.RemoveSpaceFromRunningSecurityGroupCallCount()).To(Equal(0)) 2288 }) 2289 }) 2290 }) 2291 }) 2292 })