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  })