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