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