github.com/jenspinney/cli@v6.42.1-0.20190207184520-7450c600020e+incompatible/actor/v2action/service_instance_summary_test.go (about) 1 package v2action_test 2 3 import ( 4 "errors" 5 6 . "code.cloudfoundry.org/cli/actor/v2action" 7 "code.cloudfoundry.org/cli/actor/v2action/v2actionfakes" 8 "code.cloudfoundry.org/cli/api/cloudcontroller/ccerror" 9 "code.cloudfoundry.org/cli/api/cloudcontroller/ccv2" 10 "code.cloudfoundry.org/cli/api/cloudcontroller/ccv2/constant" 11 12 . "github.com/onsi/ginkgo" 13 . "github.com/onsi/gomega" 14 ) 15 16 var _ = Describe("Service Instance Summary Actions", func() { 17 var ( 18 actor *Actor 19 fakeCloudControllerClient *v2actionfakes.FakeCloudControllerClient 20 ) 21 22 BeforeEach(func() { 23 fakeCloudControllerClient = new(v2actionfakes.FakeCloudControllerClient) 24 actor = NewActor(fakeCloudControllerClient, nil, nil) 25 }) 26 27 Describe("ServiceInstanceSummary", func() { 28 var summary ServiceInstanceSummary 29 30 Describe("IsShareable", func() { 31 When("the 'service_instance_sharing' feature flag is enabled", func() { 32 BeforeEach(func() { 33 summary.ServiceInstanceSharingFeatureFlag = true 34 }) 35 36 When("the service broker has enabled sharing", func() { 37 BeforeEach(func() { 38 summary.Service.Extra.Shareable = true 39 }) 40 41 It("returns true", func() { 42 Expect(summary.IsShareable()).To(BeTrue()) 43 }) 44 }) 45 46 When("the service broker has not enabled sharing", func() { 47 BeforeEach(func() { 48 summary.Service.Extra.Shareable = false 49 }) 50 51 It("returns true", func() { 52 Expect(summary.IsShareable()).To(BeFalse()) 53 }) 54 }) 55 }) 56 57 When("the 'service_instance_sharing' feature flag is not enabled", func() { 58 BeforeEach(func() { 59 summary.ServiceInstanceSharingFeatureFlag = false 60 }) 61 62 When("the service broker has enabled sharing", func() { 63 BeforeEach(func() { 64 summary.Service.Extra.Shareable = true 65 }) 66 67 It("returns true", func() { 68 Expect(summary.IsShareable()).To(BeFalse()) 69 }) 70 }) 71 72 When("the service broker has not enabled sharing", func() { 73 BeforeEach(func() { 74 summary.Service.Extra.Shareable = false 75 }) 76 77 It("returns true", func() { 78 Expect(summary.IsShareable()).To(BeFalse()) 79 }) 80 }) 81 }) 82 }) 83 }) 84 85 Describe("GetServiceInstanceSummaryByNameAndSpace", func() { 86 var ( 87 summary ServiceInstanceSummary 88 summaryWarnings Warnings 89 summaryErr error 90 ) 91 92 JustBeforeEach(func() { 93 summary, summaryWarnings, summaryErr = actor.GetServiceInstanceSummaryByNameAndSpace("some-service-instance", "some-space-guid") 94 }) 95 96 When("an error is encountered getting the service instance", func() { 97 var expectedErr error 98 99 BeforeEach(func() { 100 expectedErr = errors.New("get space service instance error") 101 fakeCloudControllerClient.GetSpaceServiceInstancesReturns( 102 []ccv2.ServiceInstance{}, 103 ccv2.Warnings{"get-space-service-instance-warning"}, 104 expectedErr) 105 }) 106 107 It("returns the error and all warnings", func() { 108 Expect(summaryErr).To(MatchError(expectedErr)) 109 Expect(summaryWarnings).To(ConsistOf("get-space-service-instance-warning")) 110 111 Expect(fakeCloudControllerClient.GetSpaceServiceInstancesCallCount()).To(Equal(1)) 112 spaceGUIDArg, getUserProvidedServicesArg, queriesArg := fakeCloudControllerClient.GetSpaceServiceInstancesArgsForCall(0) 113 Expect(spaceGUIDArg).To(Equal("some-space-guid")) 114 Expect(getUserProvidedServicesArg).To(BeTrue()) 115 Expect(queriesArg).To(HaveLen(1)) 116 Expect(queriesArg[0]).To(Equal(ccv2.Filter{ 117 Type: constant.NameFilter, 118 Operator: constant.EqualOperator, 119 Values: []string{"some-service-instance"}, 120 })) 121 }) 122 }) 123 124 When("no errors are encountered getting the service instance", func() { 125 var ( 126 returnedServiceInstance ccv2.ServiceInstance 127 returnedFeatureFlag ccv2.FeatureFlag 128 ) 129 130 When("the service instance is a managed service instance", func() { 131 BeforeEach(func() { 132 returnedServiceInstance = ccv2.ServiceInstance{ 133 DashboardURL: "some-dashboard", 134 GUID: "some-service-instance-guid", 135 Name: "some-service-instance", 136 ServiceGUID: "some-service-guid", 137 ServicePlanGUID: "some-service-plan-guid", 138 Tags: []string{"tag-1", "tag-2"}, 139 Type: constant.ServiceInstanceTypeManagedService, 140 } 141 fakeCloudControllerClient.GetSpaceServiceInstancesReturns( 142 []ccv2.ServiceInstance{returnedServiceInstance}, 143 ccv2.Warnings{"get-space-service-instance-warning"}, 144 nil) 145 146 returnedFeatureFlag = ccv2.FeatureFlag{ 147 Name: "service_instance_sharing", 148 Enabled: true, 149 } 150 fakeCloudControllerClient.GetConfigFeatureFlagsReturns( 151 []ccv2.FeatureFlag{returnedFeatureFlag}, 152 ccv2.Warnings{"get-feature-flags-warning"}, 153 nil) 154 }) 155 156 It("returns the service instance info and all warnings", func() { 157 Expect(summaryErr).ToNot(HaveOccurred()) 158 Expect(summary.ServiceInstance).To(Equal(ServiceInstance(returnedServiceInstance))) 159 Expect(summaryWarnings).To(ConsistOf("get-space-service-instance-warning", "get-feature-flags-warning")) 160 161 Expect(fakeCloudControllerClient.GetSpaceServiceInstancesCallCount()).To(Equal(1)) 162 spaceGUIDArg, getUserProvidedServicesArg, queriesArg := fakeCloudControllerClient.GetSpaceServiceInstancesArgsForCall(0) 163 Expect(spaceGUIDArg).To(Equal("some-space-guid")) 164 Expect(getUserProvidedServicesArg).To(BeTrue()) 165 Expect(queriesArg).To(HaveLen(1)) 166 Expect(queriesArg[0]).To(Equal(ccv2.Filter{ 167 Type: constant.NameFilter, 168 Operator: constant.EqualOperator, 169 Values: []string{"some-service-instance"}, 170 })) 171 }) 172 173 When("the service instance is shared from another space (not created in the currently targeted space)", func() { 174 When("the source space of the service instance is different from the currently targeted space", func() { 175 BeforeEach(func() { 176 returnedServiceInstance.SpaceGUID = "not-currently-targeted-space-guid" 177 fakeCloudControllerClient.GetSpaceServiceInstancesReturns( 178 []ccv2.ServiceInstance{returnedServiceInstance}, 179 ccv2.Warnings{"get-space-service-instance-warning"}, 180 nil) 181 }) 182 183 When("an error is encountered getting the shared_from information", func() { 184 var expectedErr error 185 186 When("the error is generic", func() { 187 BeforeEach(func() { 188 expectedErr = errors.New("get-service-instance-shared-from-error") 189 fakeCloudControllerClient.GetServiceInstanceSharedFromReturns( 190 ccv2.ServiceInstanceSharedFrom{}, 191 ccv2.Warnings{"get-service-instance-shared-from-warning"}, 192 expectedErr, 193 ) 194 }) 195 196 It("returns the error and all warnings", func() { 197 Expect(summaryErr).To(MatchError(expectedErr)) 198 Expect(summaryWarnings).To(ConsistOf("get-service-instance-shared-from-warning", "get-feature-flags-warning", "get-space-service-instance-warning")) 199 200 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromCallCount()).To(Equal(1)) 201 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromArgsForCall(0)).To(Equal(returnedServiceInstance.GUID)) 202 Expect(fakeCloudControllerClient.GetServiceInstanceSharedTosCallCount()).To(Equal(0)) 203 }) 204 }) 205 206 When("the API version does not support service instance sharing", func() { 207 BeforeEach(func() { 208 expectedErr = ccerror.ResourceNotFoundError{} 209 fakeCloudControllerClient.GetServiceInstanceSharedFromReturns( 210 ccv2.ServiceInstanceSharedFrom{}, 211 ccv2.Warnings{"get-service-instance-shared-from-warning"}, 212 expectedErr, 213 ) 214 }) 215 216 It("ignores the 404 error and continues without shared_from information", func() { 217 Expect(summaryErr).ToNot(HaveOccurred()) 218 Expect(summaryWarnings).To(ConsistOf("get-service-instance-shared-from-warning", "get-feature-flags-warning", "get-space-service-instance-warning")) 219 Expect(summary.ServiceInstanceSharedFrom).To(Equal(ServiceInstanceSharedFrom{})) 220 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromCallCount()).To(Equal(1)) 221 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromArgsForCall(0)).To(Equal(returnedServiceInstance.GUID)) 222 Expect(fakeCloudControllerClient.GetServiceInstanceSharedTosCallCount()).To(Equal(0)) 223 }) 224 }) 225 }) 226 227 When("no errors are encountered getting the shared_from information", func() { 228 When("the shared_from info is NOT empty", func() { 229 var returnedServiceSharedFrom ccv2.ServiceInstanceSharedFrom 230 231 BeforeEach(func() { 232 returnedServiceSharedFrom = ccv2.ServiceInstanceSharedFrom{ 233 SpaceGUID: "some-space-guid", 234 SpaceName: "some-space-name", 235 OrganizationName: "some-org-name", 236 } 237 fakeCloudControllerClient.GetServiceInstanceSharedFromReturns( 238 returnedServiceSharedFrom, 239 ccv2.Warnings{"get-service-instance-shared-from-warning"}, 240 nil) 241 }) 242 243 It("returns the service instance share type, shared_from info, and all warnings", func() { 244 Expect(summaryErr).ToNot(HaveOccurred()) 245 Expect(summary.ServiceInstance).To(Equal(ServiceInstance(returnedServiceInstance))) 246 Expect(summary.ServiceInstanceSharingFeatureFlag).To(BeTrue()) 247 Expect(summary.ServiceInstanceShareType).To(Equal(ServiceInstanceIsSharedFrom)) 248 Expect(summary.ServiceInstanceSharedFrom).To(Equal(ServiceInstanceSharedFrom(returnedServiceSharedFrom))) 249 Expect(summaryWarnings).To(ConsistOf("get-service-instance-shared-from-warning", "get-feature-flags-warning", "get-space-service-instance-warning")) 250 251 Expect(fakeCloudControllerClient.GetConfigFeatureFlagsCallCount()).To(Equal(1)) 252 253 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromCallCount()).To(Equal(1)) 254 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromArgsForCall(0)).To(Equal(returnedServiceInstance.GUID)) 255 Expect(fakeCloudControllerClient.GetServiceInstanceSharedTosCallCount()).To(Equal(0)) 256 }) 257 }) 258 259 When("the shared_from info is empty", func() { 260 It("sets the share type to not shared", func() { 261 Expect(summaryErr).ToNot(HaveOccurred()) 262 Expect(summary.ServiceInstanceShareType).To(Equal(ServiceInstanceIsNotShared)) 263 }) 264 }) 265 }) 266 }) 267 268 When("the source space of the service instance is 'null'", func() { 269 BeforeEach(func() { 270 // API returns a json null value that is unmarshalled into the empty string 271 returnedServiceInstance.SpaceGUID = "" 272 fakeCloudControllerClient.GetSpaceServiceInstancesReturns( 273 []ccv2.ServiceInstance{returnedServiceInstance}, 274 ccv2.Warnings{"get-space-service-instance-warning"}, 275 nil) 276 }) 277 278 When("an error is encountered getting the shared_from information", func() { 279 var expectedErr error 280 281 When("the error is generic", func() { 282 BeforeEach(func() { 283 expectedErr = errors.New("get-service-instance-shared-from-error") 284 fakeCloudControllerClient.GetServiceInstanceSharedFromReturns( 285 ccv2.ServiceInstanceSharedFrom{}, 286 ccv2.Warnings{"get-service-instance-shared-from-warning"}, 287 expectedErr, 288 ) 289 }) 290 291 It("returns the error and all warnings", func() { 292 Expect(summaryErr).To(MatchError(expectedErr)) 293 Expect(summaryWarnings).To(ConsistOf("get-service-instance-shared-from-warning", "get-feature-flags-warning", "get-space-service-instance-warning")) 294 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromCallCount()).To(Equal(1)) 295 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromArgsForCall(0)).To(Equal(returnedServiceInstance.GUID)) 296 }) 297 }) 298 299 When("the API version does not support service instance sharing", func() { 300 BeforeEach(func() { 301 expectedErr = ccerror.ResourceNotFoundError{} 302 fakeCloudControllerClient.GetServiceInstanceSharedFromReturns( 303 ccv2.ServiceInstanceSharedFrom{}, 304 ccv2.Warnings{"get-service-instance-shared-from-warning"}, 305 expectedErr, 306 ) 307 }) 308 309 It("ignores the 404 error and continues without shared_from information", func() { 310 Expect(summaryErr).ToNot(HaveOccurred()) 311 Expect(summaryWarnings).To(ConsistOf("get-service-instance-shared-from-warning", "get-feature-flags-warning", "get-space-service-instance-warning")) 312 Expect(summary.ServiceInstanceSharedFrom).To(Equal(ServiceInstanceSharedFrom{})) 313 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromCallCount()).To(Equal(1)) 314 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromArgsForCall(0)).To(Equal(returnedServiceInstance.GUID)) 315 }) 316 }) 317 }) 318 319 When("no errors are encountered getting the shared_from information", func() { 320 When("the shared_from info is NOT empty", func() { 321 var returnedServiceSharedFrom ccv2.ServiceInstanceSharedFrom 322 323 BeforeEach(func() { 324 returnedServiceSharedFrom = ccv2.ServiceInstanceSharedFrom{ 325 SpaceGUID: "some-space-guid", 326 SpaceName: "some-space-name", 327 OrganizationName: "some-org-name", 328 } 329 fakeCloudControllerClient.GetServiceInstanceSharedFromReturns( 330 returnedServiceSharedFrom, 331 ccv2.Warnings{"get-service-instance-shared-from-warning"}, 332 nil) 333 }) 334 335 It("returns the service instance share type, shared_from info, and all warnings", func() { 336 Expect(summaryErr).ToNot(HaveOccurred()) 337 Expect(summary.ServiceInstance).To(Equal(ServiceInstance(returnedServiceInstance))) 338 Expect(summary.ServiceInstanceSharingFeatureFlag).To(BeTrue()) 339 Expect(summary.ServiceInstanceShareType).To(Equal(ServiceInstanceIsSharedFrom)) 340 Expect(summary.ServiceInstanceSharedFrom).To(Equal(ServiceInstanceSharedFrom(returnedServiceSharedFrom))) 341 Expect(summaryWarnings).To(ConsistOf("get-space-service-instance-warning", "get-feature-flags-warning", "get-service-instance-shared-from-warning")) 342 343 Expect(fakeCloudControllerClient.GetConfigFeatureFlagsCallCount()).To(Equal(1)) 344 345 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromCallCount()).To(Equal(1)) 346 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromArgsForCall(0)).To(Equal(returnedServiceInstance.GUID)) 347 Expect(fakeCloudControllerClient.GetServiceInstanceSharedTosCallCount()).To(Equal(0)) 348 }) 349 }) 350 351 When("the shared_from info is empty", func() { 352 It("sets the share type to not shared", func() { 353 Expect(summaryErr).ToNot(HaveOccurred()) 354 Expect(summary.ServiceInstanceShareType).To(Equal(ServiceInstanceIsNotShared)) 355 }) 356 }) 357 }) 358 }) 359 }) 360 361 When("the service instance is shared to other spaces", func() { 362 When("the source space of the service instance is the same as the currently targeted space", func() { 363 BeforeEach(func() { 364 returnedServiceInstance.SpaceGUID = "some-space-guid" 365 fakeCloudControllerClient.GetSpaceServiceInstancesReturns( 366 []ccv2.ServiceInstance{returnedServiceInstance}, 367 ccv2.Warnings{"get-space-service-instance-warning"}, 368 nil) 369 }) 370 371 When("an error is encountered getting the shared_to information", func() { 372 var expectedErr error 373 374 When("the error is generic", func() { 375 BeforeEach(func() { 376 expectedErr = errors.New("get-service-instance-shared-tos-error") 377 fakeCloudControllerClient.GetServiceInstanceSharedTosReturns( 378 []ccv2.ServiceInstanceSharedTo{}, 379 ccv2.Warnings{"get-service-instance-shared-tos-warning"}, 380 expectedErr, 381 ) 382 }) 383 384 It("returns the error and all warnings", func() { 385 Expect(summaryErr).To(MatchError(expectedErr)) 386 Expect(summaryWarnings).To(ConsistOf("get-service-instance-shared-tos-warning", "get-feature-flags-warning", "get-space-service-instance-warning")) 387 Expect(fakeCloudControllerClient.GetServiceInstanceSharedTosCallCount()).To(Equal(1)) 388 Expect(fakeCloudControllerClient.GetServiceInstanceSharedTosArgsForCall(0)).To(Equal(returnedServiceInstance.GUID)) 389 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromCallCount()).To(Equal(0)) 390 }) 391 }) 392 393 When("the API version does not support service instance sharing", func() { 394 BeforeEach(func() { 395 expectedErr = ccerror.ResourceNotFoundError{} 396 fakeCloudControllerClient.GetServiceInstanceSharedTosReturns( 397 []ccv2.ServiceInstanceSharedTo{}, 398 ccv2.Warnings{"get-service-instance-shared-tos-warning"}, 399 expectedErr, 400 ) 401 }) 402 403 It("ignores the 404 error and continues without shared_to information", func() { 404 Expect(summaryErr).ToNot(HaveOccurred()) 405 Expect(summaryWarnings).To(ConsistOf("get-service-instance-shared-tos-warning", "get-feature-flags-warning", "get-space-service-instance-warning")) 406 Expect(fakeCloudControllerClient.GetServiceInstanceSharedTosCallCount()).To(Equal(1)) 407 Expect(fakeCloudControllerClient.GetServiceInstanceSharedTosArgsForCall(0)).To(Equal(returnedServiceInstance.GUID)) 408 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromCallCount()).To(Equal(0)) 409 }) 410 }) 411 }) 412 413 When("no errors are encountered getting the shared_to information", func() { 414 When("the shared_to info is NOT an empty list", func() { 415 var returnedServiceSharedTos []ccv2.ServiceInstanceSharedTo 416 417 BeforeEach(func() { 418 returnedServiceSharedTos = []ccv2.ServiceInstanceSharedTo{ 419 { 420 SpaceGUID: "some-space-guid", 421 SpaceName: "some-space-name", 422 OrganizationName: "some-org-name", 423 }, 424 { 425 SpaceGUID: "some-space-guid2", 426 SpaceName: "some-space-name2", 427 OrganizationName: "some-org-name2", 428 }, 429 } 430 431 fakeCloudControllerClient.GetServiceInstanceSharedTosReturns( 432 returnedServiceSharedTos, 433 ccv2.Warnings{"get-service-instance-shared-tos-warning"}, 434 nil) 435 }) 436 437 It("returns the service instance share type, shared_to info, and all warnings", func() { 438 Expect(summaryErr).ToNot(HaveOccurred()) 439 Expect(summary.ServiceInstance).To(Equal(ServiceInstance(returnedServiceInstance))) 440 Expect(summary.ServiceInstanceSharingFeatureFlag).To(BeTrue()) 441 Expect(summary.ServiceInstanceShareType).To(Equal(ServiceInstanceIsSharedTo)) 442 Expect(summary.ServiceInstanceSharedTos).To(ConsistOf(ServiceInstanceSharedTo(returnedServiceSharedTos[0]), ServiceInstanceSharedTo(returnedServiceSharedTos[1]))) 443 Expect(summaryWarnings).To(ConsistOf("get-service-instance-shared-tos-warning", "get-feature-flags-warning", "get-space-service-instance-warning")) 444 445 Expect(fakeCloudControllerClient.GetConfigFeatureFlagsCallCount()).To(Equal(1)) 446 447 Expect(fakeCloudControllerClient.GetServiceInstanceSharedTosCallCount()).To(Equal(1)) 448 Expect(fakeCloudControllerClient.GetServiceInstanceSharedTosArgsForCall(0)).To(Equal(returnedServiceInstance.GUID)) 449 Expect(fakeCloudControllerClient.GetServiceInstanceSharedFromCallCount()).To(Equal(0)) 450 }) 451 }) 452 453 When("the shared_to info is an empty list", func() { 454 It("sets the share type to not shared", func() { 455 Expect(summaryErr).ToNot(HaveOccurred()) 456 Expect(summary.ServiceInstanceShareType).To(Equal(ServiceInstanceIsNotShared)) 457 }) 458 }) 459 }) 460 }) 461 }) 462 463 When("an error is encountered getting the service plan", func() { 464 Describe("a generic error", func() { 465 var expectedErr error 466 467 BeforeEach(func() { 468 expectedErr = errors.New("get-service-plan-error") 469 fakeCloudControllerClient.GetServicePlanReturns( 470 ccv2.ServicePlan{}, 471 ccv2.Warnings{"get-service-plan-warning"}, 472 expectedErr) 473 }) 474 475 It("returns the error and all warnings", func() { 476 Expect(summaryErr).To(MatchError(expectedErr)) 477 Expect(summaryWarnings).To(ConsistOf("get-space-service-instance-warning", "get-feature-flags-warning", "get-service-plan-warning")) 478 }) 479 }) 480 481 Describe("a Forbidden error", func() { 482 BeforeEach(func() { 483 fakeCloudControllerClient.GetServicePlanReturns( 484 ccv2.ServicePlan{}, 485 ccv2.Warnings{"get-service-plan-warning"}, 486 ccerror.ForbiddenError{}) 487 }) 488 489 It("returns warnings and continues on", func() { 490 Expect(summaryErr).ToNot(HaveOccurred()) 491 Expect(summaryWarnings).To(ConsistOf("get-space-service-instance-warning", "get-feature-flags-warning", "get-service-plan-warning", "This org is not authorized to view necessary data about this service plan. Contact your administrator regarding service GUID some-service-plan-guid.")) 492 493 Expect(fakeCloudControllerClient.GetServiceCallCount()).To(Equal(1)) 494 Expect(fakeCloudControllerClient.GetServiceArgsForCall(0)).To(Equal("some-service-guid")) 495 }) 496 }) 497 }) 498 499 When("no errors are encountered getting the service plan", func() { 500 var returnedServicePlan ccv2.ServicePlan 501 502 BeforeEach(func() { 503 returnedServicePlan = ccv2.ServicePlan{ 504 GUID: "some-service-plan-guid", 505 Name: "some-service-plan", 506 ServiceGUID: "some-service-guid", 507 } 508 fakeCloudControllerClient.GetServicePlanReturns( 509 returnedServicePlan, 510 ccv2.Warnings{"get-service-plan-warning"}, 511 nil) 512 }) 513 514 It("returns the service plan info and all warnings", func() { 515 Expect(summaryErr).ToNot(HaveOccurred()) 516 Expect(summary.ServiceInstance).To(Equal(ServiceInstance(returnedServiceInstance))) 517 Expect(summary.ServicePlan).To(Equal(ServicePlan(returnedServicePlan))) 518 Expect(summaryWarnings).To(ConsistOf("get-space-service-instance-warning", "get-feature-flags-warning", "get-service-plan-warning")) 519 520 Expect(fakeCloudControllerClient.GetServicePlanCallCount()).To(Equal(1)) 521 Expect(fakeCloudControllerClient.GetServicePlanArgsForCall(0)).To(Equal(returnedServiceInstance.ServicePlanGUID)) 522 }) 523 524 When("an error is encountered getting the service", func() { 525 Describe("a generic error", func() { 526 var expectedErr error 527 528 BeforeEach(func() { 529 expectedErr = errors.New("get service error") 530 fakeCloudControllerClient.GetServiceReturns( 531 ccv2.Service{}, 532 ccv2.Warnings{"get-service-warning"}, 533 expectedErr) 534 }) 535 536 It("returns the error and all warnings", func() { 537 Expect(summaryErr).To(MatchError(expectedErr)) 538 Expect(summaryWarnings).To(ConsistOf("get-space-service-instance-warning", "get-feature-flags-warning", "get-service-plan-warning", "get-service-warning")) 539 540 Expect(fakeCloudControllerClient.GetServiceCallCount()).To(Equal(1)) 541 Expect(fakeCloudControllerClient.GetServiceArgsForCall(0)).To(Equal(returnedServicePlan.ServiceGUID)) 542 }) 543 }) 544 545 Describe("a Forbidden error", func() { 546 BeforeEach(func() { 547 fakeCloudControllerClient.GetServiceReturns( 548 ccv2.Service{}, 549 ccv2.Warnings{"get-service-warning"}, 550 ccerror.ForbiddenError{}) 551 }) 552 553 It("returns warnings and continues on", func() { 554 Expect(summaryErr).ToNot(HaveOccurred()) 555 Expect(summaryWarnings).To(ConsistOf("get-space-service-instance-warning", "get-feature-flags-warning", "get-service-plan-warning", "get-service-warning", "This org is not authorized to view necessary data about this service. Contact your administrator regarding service GUID some-service-guid.")) 556 557 Expect(fakeCloudControllerClient.GetServiceInstanceServiceBindingsCallCount()).To(BeNumerically(">=", 1)) 558 }) 559 }) 560 }) 561 562 When("no errors are encountered getting the service", func() { 563 var returnedService ccv2.Service 564 565 BeforeEach(func() { 566 returnedService = ccv2.Service{ 567 GUID: "some-service-guid", 568 Label: "some-service", 569 Description: "some-description", 570 DocumentationURL: "some-url", 571 Extra: ccv2.ServiceExtra{ 572 Shareable: true, 573 }, 574 } 575 576 fakeCloudControllerClient.GetServiceReturns( 577 returnedService, 578 ccv2.Warnings{"get-service-warning"}, 579 nil) 580 }) 581 582 It("returns the service info and all warnings", func() { 583 Expect(summaryErr).ToNot(HaveOccurred()) 584 Expect(summary.ServiceInstance).To(Equal(ServiceInstance(returnedServiceInstance))) 585 Expect(summary.ServicePlan).To(Equal(ServicePlan(returnedServicePlan))) 586 Expect(summary.Service).To(Equal(Service(returnedService))) 587 Expect(summaryWarnings).To(ConsistOf("get-space-service-instance-warning", "get-feature-flags-warning", "get-service-plan-warning", "get-service-warning")) 588 589 Expect(fakeCloudControllerClient.GetServiceCallCount()).To(Equal(1)) 590 Expect(fakeCloudControllerClient.GetServiceArgsForCall(0)).To(Equal(returnedServicePlan.ServiceGUID)) 591 }) 592 593 When("an error is encountered getting the service bindings", func() { 594 var expectedErr error 595 596 BeforeEach(func() { 597 expectedErr = errors.New("get service bindings error") 598 fakeCloudControllerClient.GetServiceInstanceServiceBindingsReturns( 599 []ccv2.ServiceBinding{}, 600 ccv2.Warnings{"get-service-bindings-warning"}, 601 expectedErr) 602 }) 603 604 It("returns the error and all warnings", func() { 605 Expect(summaryErr).To(MatchError(expectedErr)) 606 Expect(summaryWarnings).To(ConsistOf("get-space-service-instance-warning", "get-feature-flags-warning", "get-service-plan-warning", "get-service-warning", "get-service-bindings-warning")) 607 608 Expect(fakeCloudControllerClient.GetServiceInstanceServiceBindingsCallCount()).To(Equal(1)) 609 Expect(fakeCloudControllerClient.GetServiceInstanceServiceBindingsArgsForCall(0)).To(Equal(returnedServiceInstance.GUID)) 610 }) 611 }) 612 613 When("no errors are encountered getting the service bindings", func() { 614 var returnedServiceBindings []ccv2.ServiceBinding 615 616 BeforeEach(func() { 617 returnedServiceBindings = []ccv2.ServiceBinding{ 618 { 619 GUID: "some-service-binding-1-guid", 620 Name: "some-service-binding-1", 621 AppGUID: "some-app-1-guid", 622 LastOperation: ccv2.LastOperation{Type: "create", State: constant.LastOperationInProgress, Description: "10% complete"}, 623 }, 624 { 625 GUID: "some-service-binding-2-guid", 626 Name: "some-service-binding-2", 627 AppGUID: "some-app-2-guid", 628 LastOperation: ccv2.LastOperation{Type: "delete", State: constant.LastOperationSucceeded, Description: "100% complete"}, 629 }, 630 } 631 fakeCloudControllerClient.GetServiceInstanceServiceBindingsReturns( 632 returnedServiceBindings, 633 ccv2.Warnings{"get-service-bindings-warning"}, 634 nil) 635 }) 636 637 When("an error is encountered getting bound application info", func() { 638 var expectedErr error 639 640 BeforeEach(func() { 641 expectedErr = errors.New("get application error") 642 fakeCloudControllerClient.GetApplicationReturns( 643 ccv2.Application{}, 644 ccv2.Warnings{"get-application-warning"}, 645 expectedErr) 646 }) 647 648 It("returns the error", func() { 649 Expect(summaryErr).To(MatchError(expectedErr)) 650 Expect(summaryWarnings).To(ConsistOf("get-space-service-instance-warning", "get-feature-flags-warning", "get-service-plan-warning", "get-service-warning", "get-service-bindings-warning", "get-application-warning")) 651 652 Expect(fakeCloudControllerClient.GetApplicationCallCount()).To(Equal(1)) 653 Expect(fakeCloudControllerClient.GetApplicationArgsForCall(0)).To(Equal(returnedServiceBindings[0].AppGUID)) 654 }) 655 }) 656 657 When("no errors are encountered getting bound application info", func() { 658 BeforeEach(func() { 659 fakeCloudControllerClient.GetApplicationReturnsOnCall( 660 0, 661 ccv2.Application{ 662 GUID: "some-app-1-guid", 663 Name: "some-app-1", 664 }, 665 ccv2.Warnings{"get-application-warning-1"}, 666 nil) 667 fakeCloudControllerClient.GetApplicationReturnsOnCall( 668 1, 669 ccv2.Application{ 670 GUID: "some-app-2-guid", 671 Name: "some-app-2", 672 }, 673 ccv2.Warnings{"get-application-warning-2"}, 674 nil) 675 }) 676 677 It("returns a list of applications bound to the service instance and all warnings", func() { 678 Expect(summaryErr).ToNot(HaveOccurred()) 679 Expect(summary.ServiceInstance).To(Equal(ServiceInstance(returnedServiceInstance))) 680 Expect(summary.ServicePlan).To(Equal(ServicePlan(returnedServicePlan))) 681 Expect(summary.Service).To(Equal(Service(returnedService))) 682 Expect(summary.BoundApplications).To(Equal([]BoundApplication{ 683 { 684 AppName: "some-app-1", 685 ServiceBindingName: "some-service-binding-1", 686 LastOperation: LastOperation{ 687 Type: "create", 688 State: constant.LastOperationInProgress, 689 Description: "10% complete", 690 }, 691 }, 692 { 693 AppName: "some-app-2", 694 ServiceBindingName: "some-service-binding-2", 695 LastOperation: LastOperation{ 696 Type: "delete", 697 State: constant.LastOperationSucceeded, 698 Description: "100% complete", 699 }, 700 }, 701 })) 702 Expect(summaryWarnings).To(ConsistOf("get-space-service-instance-warning", "get-feature-flags-warning", "get-service-plan-warning", "get-service-warning", "get-service-bindings-warning", "get-application-warning-1", "get-application-warning-2")) 703 704 Expect(fakeCloudControllerClient.GetServiceInstanceServiceBindingsCallCount()).To(Equal(1)) 705 Expect(fakeCloudControllerClient.GetServiceInstanceServiceBindingsArgsForCall(0)).To(Equal(returnedServiceInstance.GUID)) 706 707 Expect(fakeCloudControllerClient.GetApplicationCallCount()).To(Equal(2)) 708 Expect(fakeCloudControllerClient.GetApplicationArgsForCall(0)).To(Equal(returnedServiceBindings[0].AppGUID)) 709 Expect(fakeCloudControllerClient.GetApplicationArgsForCall(1)).To(Equal(returnedServiceBindings[1].AppGUID)) 710 711 Expect(fakeCloudControllerClient.GetUserProvidedServiceInstanceServiceBindingsCallCount()).To(Equal(0)) 712 }) 713 }) 714 }) 715 }) 716 }) 717 }) 718 719 When("the service instance is a user provided service instance", func() { 720 BeforeEach(func() { 721 returnedServiceInstance = ccv2.ServiceInstance{ 722 GUID: "some-user-provided-service-instance-guid", 723 Name: "some-user-provided-service-instance", 724 Type: constant.ServiceInstanceTypeUserProvidedService, 725 } 726 fakeCloudControllerClient.GetSpaceServiceInstancesReturns( 727 []ccv2.ServiceInstance{returnedServiceInstance}, 728 ccv2.Warnings{"get-space-service-instance-warning"}, 729 nil) 730 }) 731 732 Context("getting the service bindings errors", func() { 733 BeforeEach(func() { 734 fakeCloudControllerClient.GetUserProvidedServiceInstanceServiceBindingsReturns( 735 nil, 736 ccv2.Warnings{"some-get-user-provided-si-bindings-warnings"}, 737 errors.New("some-get-user-provided-si-bindings-error")) 738 }) 739 740 It("should return the error and return all warnings", func() { 741 Expect(summaryErr).To(MatchError("some-get-user-provided-si-bindings-error")) 742 Expect(summaryWarnings).To(ConsistOf("some-get-user-provided-si-bindings-warnings", 743 "get-space-service-instance-warning")) 744 }) 745 }) 746 747 When("no errors are encountered getting the service bindings", func() { 748 var returnedServiceBindings []ccv2.ServiceBinding 749 750 BeforeEach(func() { 751 returnedServiceBindings = []ccv2.ServiceBinding{ 752 { 753 GUID: "some-service-binding-1-guid", 754 Name: "some-service-binding-1", 755 AppGUID: "some-app-1-guid", 756 }, 757 { 758 GUID: "some-service-binding-2-guid", 759 Name: "some-service-binding-2", 760 AppGUID: "some-app-2-guid", 761 }, 762 } 763 fakeCloudControllerClient.GetUserProvidedServiceInstanceServiceBindingsReturns( 764 returnedServiceBindings, 765 ccv2.Warnings{"get-service-bindings-warning"}, 766 nil) 767 }) 768 769 When("no errors are encountered getting bound application info", func() { 770 BeforeEach(func() { 771 fakeCloudControllerClient.GetApplicationReturnsOnCall( 772 0, 773 ccv2.Application{ 774 GUID: "some-app-1-guid", 775 Name: "some-app-1", 776 }, 777 ccv2.Warnings{"get-application-warning-1"}, 778 nil) 779 fakeCloudControllerClient.GetApplicationReturnsOnCall( 780 1, 781 ccv2.Application{ 782 GUID: "some-app-2-guid", 783 Name: "some-app-2", 784 }, 785 ccv2.Warnings{"get-application-warning-2"}, 786 nil) 787 }) 788 789 It("returns a list of applications bound to the service instance and all warnings", func() { 790 Expect(summaryErr).ToNot(HaveOccurred()) 791 Expect(summary).To(Equal(ServiceInstanceSummary{ 792 ServiceInstance: ServiceInstance(returnedServiceInstance), 793 BoundApplications: []BoundApplication{ 794 { 795 AppName: "some-app-1", 796 ServiceBindingName: "some-service-binding-1", 797 }, 798 { 799 AppName: "some-app-2", 800 ServiceBindingName: "some-service-binding-2", 801 }, 802 }, 803 })) 804 Expect(summaryWarnings).To(ConsistOf("get-space-service-instance-warning", "get-service-bindings-warning", "get-application-warning-1", "get-application-warning-2")) 805 806 Expect(fakeCloudControllerClient.GetSpaceServiceInstancesCallCount()).To(Equal(1)) 807 spaceGUIDArg, getUserProvidedServicesArg, queriesArg := fakeCloudControllerClient.GetSpaceServiceInstancesArgsForCall(0) 808 Expect(spaceGUIDArg).To(Equal("some-space-guid")) 809 Expect(getUserProvidedServicesArg).To(BeTrue()) 810 Expect(queriesArg).To(HaveLen(1)) 811 Expect(queriesArg[0]).To(Equal(ccv2.Filter{ 812 Type: constant.NameFilter, 813 Operator: constant.EqualOperator, 814 Values: []string{"some-service-instance"}, 815 })) 816 817 Expect(fakeCloudControllerClient.GetUserProvidedServiceInstanceServiceBindingsCallCount()).To(Equal(1)) 818 Expect(fakeCloudControllerClient.GetUserProvidedServiceInstanceServiceBindingsArgsForCall(0)).To(Equal(returnedServiceInstance.GUID)) 819 820 Expect(fakeCloudControllerClient.GetApplicationCallCount()).To(Equal(2)) 821 Expect(fakeCloudControllerClient.GetApplicationArgsForCall(0)).To(Equal(returnedServiceBindings[0].AppGUID)) 822 Expect(fakeCloudControllerClient.GetApplicationArgsForCall(1)).To(Equal(returnedServiceBindings[1].AppGUID)) 823 824 Expect(fakeCloudControllerClient.GetServicePlanCallCount()).To(Equal(0)) 825 Expect(fakeCloudControllerClient.GetServiceCallCount()).To(Equal(0)) 826 Expect(fakeCloudControllerClient.GetServiceInstanceServiceBindingsCallCount()).To(Equal(0)) 827 }) 828 }) 829 }) 830 }) 831 }) 832 }) 833 834 Describe("GetServiceInstancesSummaryBySpace", func() { 835 var ( 836 serviceInstancesSummary []ServiceInstanceSummary 837 warnings Warnings 838 executeErr error 839 ) 840 841 JustBeforeEach(func() { 842 serviceInstancesSummary, warnings, executeErr = actor.GetServiceInstancesSummaryBySpace("some-space-GUID") 843 }) 844 845 When("an error is encountered getting a space's summary", func() { 846 var expectedErr error 847 848 BeforeEach(func() { 849 expectedErr = errors.New("summary error") 850 851 fakeCloudControllerClient.GetSpaceSummaryReturns( 852 ccv2.SpaceSummary{}, 853 ccv2.Warnings{"get-by-space-service-instances-warning"}, 854 expectedErr, 855 ) 856 }) 857 858 It("returns the error and all warnings", func() { 859 Expect(executeErr).To(MatchError(expectedErr)) 860 Expect(warnings).To(ConsistOf("get-by-space-service-instances-warning")) 861 }) 862 }) 863 864 When("no errors are encountered getting a space's summary", func() { 865 BeforeEach(func() { 866 fakeCloudControllerClient.GetServicesReturns( 867 []ccv2.Service{ 868 { 869 GUID: "service-guid-1", 870 Label: "service-label", 871 ServiceBrokerName: "some-broker", 872 }, 873 { 874 GUID: "service-guid-2", 875 Label: "service-label", 876 ServiceBrokerName: "other-broker", 877 }, 878 }, 879 ccv2.Warnings{"get-space-services-warning"}, 880 nil, 881 ) 882 fakeCloudControllerClient.GetSpaceSummaryReturns( 883 ccv2.SpaceSummary{ 884 Name: "space-name", 885 Applications: []ccv2.SpaceSummaryApplication{ 886 { 887 Name: "1-app-name", 888 ServiceNames: []string{"managed-service-instance", "user-provided-service-instance"}, 889 }, 890 { 891 Name: "2-app-name", 892 ServiceNames: []string{"managed-service-instance"}, 893 }, 894 }, 895 ServiceInstances: []ccv2.SpaceSummaryServiceInstance{ 896 { 897 Name: "managed-service-instance", 898 ServicePlan: ccv2.SpaceSummaryServicePlan{ 899 GUID: "plan-guid", 900 Name: "simple-plan", 901 Service: ccv2.SpaceSummaryService{ 902 GUID: "service-guid-1", 903 Label: "service-label", 904 ServiceBrokerName: "some-broker", 905 }, 906 }, 907 LastOperation: ccv2.LastOperation{ 908 Type: "create", 909 State: "succeeded", 910 Description: "a description", 911 }, 912 }, 913 { 914 Name: "user-provided-service-instance", 915 }, 916 }, 917 }, 918 ccv2.Warnings{"get-space-summary-warning"}, 919 nil, 920 ) 921 }) 922 923 It("returns the service instances summary with bound apps and all warnings", func() { 924 Expect(executeErr).NotTo(HaveOccurred()) 925 Expect(warnings).To(ConsistOf("get-space-summary-warning", "get-space-services-warning")) 926 Expect(serviceInstancesSummary).To(Equal([]ServiceInstanceSummary{ 927 { 928 ServiceInstance: ServiceInstance{ 929 Name: "managed-service-instance", 930 Type: constant.ServiceInstanceTypeManagedService, 931 LastOperation: ccv2.LastOperation{ 932 Type: "create", 933 State: "succeeded", 934 Description: "a description", 935 }, 936 }, 937 ServicePlan: ServicePlan{ 938 Name: "simple-plan", 939 }, 940 Service: Service{ 941 Label: "service-label", 942 ServiceBrokerName: "some-broker", 943 }, 944 BoundApplications: []BoundApplication{ 945 {AppName: "1-app-name"}, 946 {AppName: "2-app-name"}, 947 }, 948 }, 949 { 950 ServiceInstance: ServiceInstance{ 951 Name: "user-provided-service-instance", 952 Type: constant.ServiceInstanceTypeUserProvidedService, 953 }, 954 BoundApplications: []BoundApplication{ 955 {AppName: "1-app-name"}, 956 }, 957 }, 958 }, 959 )) 960 }) 961 962 When("an error is encountered getting all services", func() { 963 BeforeEach(func() { 964 fakeCloudControllerClient.GetServicesReturns( 965 []ccv2.Service{}, 966 ccv2.Warnings{"warning-1", "warning-2"}, 967 errors.New("oops"), 968 ) 969 }) 970 971 It("returns the error and all warnings", func() { 972 Expect(executeErr).To(MatchError(errors.New("oops"))) 973 Expect(warnings).To(ConsistOf("get-space-summary-warning", "warning-1", "warning-2")) 974 }) 975 }) 976 }) 977 }) 978 })