github.com/loafoe/cli@v7.1.0+incompatible/actor/v2v3action/service_instance_test.go (about)

     1  package v2v3action_test
     2  
     3  import (
     4  	"errors"
     5  
     6  	"code.cloudfoundry.org/cli/actor/actionerror"
     7  	"code.cloudfoundry.org/cli/actor/v2action"
     8  	. "code.cloudfoundry.org/cli/actor/v2v3action"
     9  	"code.cloudfoundry.org/cli/actor/v2v3action/v2v3actionfakes"
    10  	"code.cloudfoundry.org/cli/actor/v3action"
    11  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv2"
    12  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv2/constant"
    13  	"code.cloudfoundry.org/cli/resources"
    14  
    15  	. "github.com/onsi/ginkgo"
    16  	. "github.com/onsi/gomega"
    17  )
    18  
    19  var _ = Describe("Service Instance Actions", func() {
    20  	var (
    21  		actor       *Actor
    22  		fakeV2Actor *v2v3actionfakes.FakeV2Actor
    23  		fakeV3Actor *v2v3actionfakes.FakeV3Actor
    24  	)
    25  
    26  	BeforeEach(func() {
    27  		fakeV2Actor = new(v2v3actionfakes.FakeV2Actor)
    28  		fakeV3Actor = new(v2v3actionfakes.FakeV3Actor)
    29  		actor = NewActor(fakeV2Actor, fakeV3Actor)
    30  	})
    31  
    32  	Describe("ShareServiceInstanceToSpaceNameByNameAndSpaceAndOrganization", func() {
    33  		var (
    34  			shareToSpaceName    string
    35  			serviceInstanceName string
    36  			sourceSpaceGUID     string
    37  			shareToOrgGUID      string
    38  
    39  			warnings Warnings
    40  			shareErr error
    41  		)
    42  
    43  		BeforeEach(func() {
    44  			shareToSpaceName = "some-space-name"
    45  			serviceInstanceName = "some-service-instance"
    46  			sourceSpaceGUID = "some-source-space-guid"
    47  			shareToOrgGUID = "some-org-guid"
    48  		})
    49  
    50  		JustBeforeEach(func() {
    51  			warnings, shareErr = actor.ShareServiceInstanceToSpaceNameByNameAndSpaceAndOrganization(shareToSpaceName, serviceInstanceName, sourceSpaceGUID, shareToOrgGUID)
    52  		})
    53  
    54  		When("no errors occur getting the service instance", func() {
    55  			When("no errors occur getting the space we are sharing to", func() {
    56  				When("the service instance is a managed service instance", func() {
    57  					BeforeEach(func() {
    58  						fakeV2Actor.GetServiceInstanceByNameAndSpaceReturns(
    59  							v2action.ServiceInstance{
    60  								GUID:        "some-service-instance-guid",
    61  								ServiceGUID: "some-service-guid",
    62  								Type:        constant.ManagedService,
    63  							},
    64  							v2action.Warnings{"get-service-instance-warning"},
    65  							nil)
    66  
    67  						fakeV2Actor.GetSpaceByOrganizationAndNameReturns(
    68  							v2action.Space{
    69  								GUID: "not-shared-space-guid",
    70  							},
    71  							v2action.Warnings{"get-space-warning"},
    72  							nil)
    73  					})
    74  
    75  					When("no errors occur getting the service", func() {
    76  						BeforeEach(func() {
    77  							fakeV2Actor.GetServiceReturns(
    78  								v2action.Service{
    79  									Extra: ccv2.ServiceExtra{
    80  										Shareable: true,
    81  									},
    82  								},
    83  								v2action.Warnings{"get-service-warning"},
    84  								nil)
    85  						})
    86  
    87  						When("no errors occur getting feature flags", func() {
    88  							BeforeEach(func() {
    89  								fakeV2Actor.GetFeatureFlagsReturns(
    90  									[]v2action.FeatureFlag{
    91  										{
    92  											Name:    "some-feature-flag",
    93  											Enabled: true,
    94  										},
    95  										{
    96  											Name:    "service_instance_sharing",
    97  											Enabled: true,
    98  										},
    99  									},
   100  									v2action.Warnings{"get-feature-flags-warning"},
   101  									nil)
   102  							})
   103  
   104  							When("no errors occur getting the spaces the service instance is shared to", func() {
   105  								BeforeEach(func() {
   106  									fakeV2Actor.GetServiceInstanceSharedTosByServiceInstanceReturns(
   107  										[]v2action.ServiceInstanceSharedTo{
   108  											{SpaceGUID: "already-shared-space-guid-1"},
   109  											{SpaceGUID: "already-shared-space-guid-2"},
   110  										},
   111  										v2action.Warnings{"get-service-instance-shared-tos-warning"},
   112  										nil)
   113  								})
   114  
   115  								When("the service instance is NOT already shared with this space", func() {
   116  									When("no errors occur sharing the service instance to this space", func() {
   117  										BeforeEach(func() {
   118  											fakeV3Actor.ShareServiceInstanceToSpacesReturns(
   119  												resources.RelationshipList{
   120  													GUIDs: []string{"some-space-guid"},
   121  												},
   122  												v3action.Warnings{"share-service-instance-warning"},
   123  												nil)
   124  										})
   125  
   126  										It("shares the service instance to this space and returns all warnings", func() {
   127  											Expect(shareErr).ToNot(HaveOccurred())
   128  											Expect(warnings).To(ConsistOf(
   129  												"get-service-instance-warning",
   130  												"get-space-warning",
   131  												"get-service-warning",
   132  												"get-feature-flags-warning",
   133  												"get-service-instance-shared-tos-warning",
   134  												"share-service-instance-warning"))
   135  
   136  											Expect(fakeV2Actor.GetServiceInstanceByNameAndSpaceCallCount()).To(Equal(1))
   137  											serviceInstanceNameArg, spaceGUIDArg := fakeV2Actor.GetServiceInstanceByNameAndSpaceArgsForCall(0)
   138  											Expect(serviceInstanceNameArg).To(Equal(serviceInstanceName))
   139  											Expect(spaceGUIDArg).To(Equal(sourceSpaceGUID))
   140  
   141  											Expect(fakeV2Actor.GetServiceCallCount()).To(Equal(1))
   142  											Expect(fakeV2Actor.GetServiceArgsForCall(0)).To(Equal("some-service-guid"))
   143  
   144  											Expect(fakeV2Actor.GetFeatureFlagsCallCount()).To(Equal(1))
   145  
   146  											Expect(fakeV2Actor.GetServiceInstanceSharedTosByServiceInstanceCallCount()).To(Equal(1))
   147  											Expect(fakeV2Actor.GetServiceInstanceSharedTosByServiceInstanceArgsForCall(0)).To(Equal("some-service-instance-guid"))
   148  
   149  											Expect(fakeV2Actor.GetSpaceByOrganizationAndNameCallCount()).To(Equal(1))
   150  											orgGUIDArg, spaceNameArg := fakeV2Actor.GetSpaceByOrganizationAndNameArgsForCall(0)
   151  											Expect(orgGUIDArg).To(Equal(shareToOrgGUID))
   152  											Expect(spaceNameArg).To(Equal(shareToSpaceName))
   153  
   154  											Expect(fakeV3Actor.ShareServiceInstanceToSpacesCallCount()).To(Equal(1))
   155  											serviceInstanceGUIDArg, spaceGUIDsArg := fakeV3Actor.ShareServiceInstanceToSpacesArgsForCall(0)
   156  											Expect(serviceInstanceGUIDArg).To(Equal("some-service-instance-guid"))
   157  											Expect(spaceGUIDsArg).To(Equal([]string{"not-shared-space-guid"}))
   158  										})
   159  									})
   160  
   161  									When("an error occurs sharing the service instance to this space", func() {
   162  										var expectedErr error
   163  
   164  										BeforeEach(func() {
   165  											expectedErr = errors.New("share service instance error")
   166  											fakeV3Actor.ShareServiceInstanceToSpacesReturns(
   167  												resources.RelationshipList{},
   168  												v3action.Warnings{"share-service-instance-warning"},
   169  												expectedErr)
   170  										})
   171  
   172  										It("returns the error and all warnings", func() {
   173  											Expect(shareErr).To(MatchError(expectedErr))
   174  											Expect(warnings).To(ConsistOf(
   175  												"get-service-instance-warning",
   176  												"get-service-warning",
   177  												"get-feature-flags-warning",
   178  												"get-service-instance-shared-tos-warning",
   179  												"get-space-warning",
   180  												"share-service-instance-warning"))
   181  										})
   182  									})
   183  								})
   184  
   185  								When("the service instance IS already shared with this space", func() {
   186  									BeforeEach(func() {
   187  										fakeV2Actor.GetSpaceByOrganizationAndNameReturns(
   188  											v2action.Space{
   189  												GUID: "already-shared-space-guid-2",
   190  											},
   191  											v2action.Warnings{"get-space-warning"},
   192  											nil)
   193  									})
   194  
   195  									It("returns a ServiceInstanceAlreadySharedError and all warnings", func() {
   196  										Expect(shareErr).To(MatchError(actionerror.ServiceInstanceAlreadySharedError{}))
   197  										Expect(warnings).To(ConsistOf(
   198  											"get-service-instance-warning",
   199  											"get-service-warning",
   200  											"get-feature-flags-warning",
   201  											"get-service-instance-shared-tos-warning",
   202  											"get-space-warning",
   203  										))
   204  									})
   205  								})
   206  							})
   207  
   208  							When("an error occurs getting the spaces the service instance is shared to", func() {
   209  								var expectedErr error
   210  
   211  								BeforeEach(func() {
   212  									expectedErr = errors.New("get shared to spaces error")
   213  									fakeV2Actor.GetServiceInstanceSharedTosByServiceInstanceReturns(
   214  										nil,
   215  										v2action.Warnings{"get-service-instance-shared-tos-warning"},
   216  										expectedErr)
   217  								})
   218  
   219  								It("returns the error and all warnings", func() {
   220  									Expect(shareErr).To(MatchError(expectedErr))
   221  									Expect(warnings).To(ConsistOf(
   222  										"get-service-instance-warning",
   223  										"get-space-warning",
   224  										"get-service-warning",
   225  										"get-feature-flags-warning",
   226  										"get-service-instance-shared-tos-warning"))
   227  								})
   228  							})
   229  						})
   230  
   231  						When("an error occurs getting feature flags", func() {
   232  							var expectedErr error
   233  
   234  							BeforeEach(func() {
   235  								expectedErr = errors.New("get feature flags error")
   236  								fakeV2Actor.GetFeatureFlagsReturns(
   237  									nil,
   238  									v2action.Warnings{"get-feature-flag-warning"},
   239  									expectedErr)
   240  							})
   241  
   242  							It("returns the error and all warnings", func() {
   243  								Expect(shareErr).To(MatchError(expectedErr))
   244  								Expect(warnings).To(ConsistOf(
   245  									"get-service-instance-warning",
   246  									"get-space-warning",
   247  									"get-service-warning",
   248  									"get-feature-flag-warning"))
   249  							})
   250  						})
   251  					})
   252  
   253  					When("an error occurs getting the service", func() {
   254  						var expectedErr error
   255  
   256  						BeforeEach(func() {
   257  							expectedErr = errors.New("get service error")
   258  							fakeV2Actor.GetServiceReturns(
   259  								v2action.Service{},
   260  								v2action.Warnings{"get-service-warning"},
   261  								expectedErr)
   262  						})
   263  
   264  						It("returns the error and all warnings", func() {
   265  							Expect(shareErr).To(MatchError(expectedErr))
   266  							Expect(warnings).To(ConsistOf(
   267  								"get-service-instance-warning",
   268  								"get-space-warning",
   269  								"get-service-warning"))
   270  						})
   271  					})
   272  
   273  					When("service sharing is globally disabled, and service sharing is disabled by the service broker", func() {
   274  						BeforeEach(func() {
   275  							fakeV2Actor.GetServiceReturns(
   276  								v2action.Service{
   277  									Extra: ccv2.ServiceExtra{
   278  										Shareable: false,
   279  									},
   280  								},
   281  								v2action.Warnings{"get-service-warning"},
   282  								nil)
   283  
   284  							fakeV2Actor.GetFeatureFlagsReturns(
   285  								[]v2action.FeatureFlag{
   286  									{
   287  										Name:    "some-feature-flag",
   288  										Enabled: true,
   289  									},
   290  									{
   291  										Name:    "service_instance_sharing",
   292  										Enabled: false,
   293  									},
   294  								},
   295  								v2action.Warnings{"get-feature-flags-warning"},
   296  								nil)
   297  						})
   298  
   299  						It("returns ServiceInstanceNotShareableError and all warnings", func() {
   300  							Expect(shareErr).To(MatchError(actionerror.ServiceInstanceNotShareableError{
   301  								FeatureFlagEnabled:          false,
   302  								ServiceBrokerSharingEnabled: false}))
   303  							Expect(warnings).To(ConsistOf(
   304  								"get-service-instance-warning",
   305  								"get-space-warning",
   306  								"get-service-warning",
   307  								"get-feature-flags-warning"))
   308  						})
   309  					})
   310  
   311  					When("service sharing is globally enabled, and service sharing is disabled by the service broker", func() {
   312  						BeforeEach(func() {
   313  							fakeV2Actor.GetServiceReturns(
   314  								v2action.Service{
   315  									Extra: ccv2.ServiceExtra{
   316  										Shareable: false,
   317  									},
   318  								},
   319  								v2action.Warnings{"get-service-warning"},
   320  								nil)
   321  
   322  							fakeV2Actor.GetFeatureFlagsReturns(
   323  								[]v2action.FeatureFlag{
   324  									{
   325  										Name:    "some-feature-flag",
   326  										Enabled: true,
   327  									},
   328  									{
   329  										Name:    "service_instance_sharing",
   330  										Enabled: true,
   331  									},
   332  								},
   333  								v2action.Warnings{"get-feature-flags-warning"},
   334  								nil)
   335  						})
   336  
   337  						It("returns ServiceInstanceNotShareableError and all warnings", func() {
   338  							Expect(shareErr).To(MatchError(actionerror.ServiceInstanceNotShareableError{
   339  								FeatureFlagEnabled:          true,
   340  								ServiceBrokerSharingEnabled: false}))
   341  							Expect(warnings).To(ConsistOf(
   342  								"get-service-instance-warning",
   343  								"get-space-warning",
   344  								"get-service-warning",
   345  								"get-feature-flags-warning"))
   346  						})
   347  					})
   348  
   349  					When("service sharing is globally disabled, and service sharing is enabled by the service broker", func() {
   350  						BeforeEach(func() {
   351  							fakeV2Actor.GetServiceReturns(
   352  								v2action.Service{
   353  									Extra: ccv2.ServiceExtra{
   354  										Shareable: true,
   355  									},
   356  								},
   357  								v2action.Warnings{"get-service-warning"},
   358  								nil)
   359  
   360  							fakeV2Actor.GetFeatureFlagsReturns(
   361  								[]v2action.FeatureFlag{
   362  									{
   363  										Name:    "some-feature-flag",
   364  										Enabled: true,
   365  									},
   366  									{
   367  										Name:    "service_instance_sharing",
   368  										Enabled: false,
   369  									},
   370  								},
   371  								v2action.Warnings{"get-feature-flags-warning"},
   372  								nil)
   373  						})
   374  
   375  						It("returns ServiceInstanceNotShareableError and all warnings", func() {
   376  							Expect(shareErr).To(MatchError(actionerror.ServiceInstanceNotShareableError{
   377  								FeatureFlagEnabled:          false,
   378  								ServiceBrokerSharingEnabled: true}))
   379  							Expect(warnings).To(ConsistOf(
   380  								"get-service-instance-warning",
   381  								"get-space-warning",
   382  								"get-service-warning",
   383  								"get-feature-flags-warning"))
   384  						})
   385  					})
   386  				})
   387  
   388  				When("the service instance is not a managed service instance", func() {
   389  					BeforeEach(func() {
   390  						fakeV2Actor.GetServiceInstanceByNameAndSpaceReturns(
   391  							v2action.ServiceInstance{
   392  								GUID:        "some-service-instance-guid",
   393  								ServiceGUID: "some-service-guid",
   394  								Type:        constant.UserProvidedService,
   395  							},
   396  							v2action.Warnings{"get-service-instance-warning"},
   397  							nil)
   398  
   399  						fakeV2Actor.GetSpaceByOrganizationAndNameReturns(
   400  							v2action.Space{
   401  								GUID: "some-space",
   402  							},
   403  							v2action.Warnings{"get-space-warning"},
   404  							nil)
   405  
   406  						fakeV3Actor.ShareServiceInstanceToSpacesReturns(
   407  							resources.RelationshipList{},
   408  							v3action.Warnings{"share-service-instance-warning"},
   409  							errors.New("User-provided services cannot be shared"))
   410  					})
   411  
   412  					It("always returns the error and warnings", func() {
   413  						Expect(shareErr).To(MatchError("User-provided services cannot be shared"))
   414  						Expect(warnings).To(ConsistOf(
   415  							"get-service-instance-warning",
   416  							"get-space-warning",
   417  							"share-service-instance-warning"))
   418  
   419  						Expect(fakeV2Actor.GetServiceCallCount()).To(Equal(0))
   420  						Expect(fakeV2Actor.GetFeatureFlagsCallCount()).To(Equal(0))
   421  						Expect(fakeV2Actor.GetServiceInstanceSharedTosByServiceInstanceCallCount()).To(Equal(0))
   422  					})
   423  				})
   424  			})
   425  
   426  			When("an error occurs getting the space we are sharing to", func() {
   427  				var expectedErr error
   428  
   429  				BeforeEach(func() {
   430  					fakeV2Actor.GetServiceInstanceByNameAndSpaceReturns(
   431  						v2action.ServiceInstance{},
   432  						v2action.Warnings{"get-service-instance-warning"},
   433  						nil)
   434  
   435  					expectedErr = errors.New("get space error")
   436  					fakeV2Actor.GetSpaceByOrganizationAndNameReturns(
   437  						v2action.Space{},
   438  						v2action.Warnings{"get-space-warning"},
   439  						expectedErr)
   440  				})
   441  
   442  				It("returns the error and all warnings", func() {
   443  					Expect(shareErr).To(MatchError(expectedErr))
   444  					Expect(warnings).To(ConsistOf(
   445  						"get-service-instance-warning",
   446  						"get-space-warning"))
   447  				})
   448  			})
   449  		})
   450  
   451  		When("an error occurs getting the service instance", func() {
   452  			var expectedErr error
   453  
   454  			BeforeEach(func() {
   455  				expectedErr = errors.New("get service instance error")
   456  				fakeV2Actor.GetServiceInstanceByNameAndSpaceReturns(
   457  					v2action.ServiceInstance{},
   458  					v2action.Warnings{"get-service-instance-warning"},
   459  					expectedErr)
   460  			})
   461  
   462  			It("returns the error and all warnings", func() {
   463  				Expect(shareErr).To(MatchError(expectedErr))
   464  				Expect(warnings).To(ConsistOf("get-service-instance-warning"))
   465  			})
   466  		})
   467  
   468  		When("the service instance does not exist", func() {
   469  			BeforeEach(func() {
   470  				fakeV2Actor.GetServiceInstanceByNameAndSpaceReturns(
   471  					v2action.ServiceInstance{},
   472  					v2action.Warnings{"get-service-instance-warning"},
   473  					actionerror.ServiceInstanceNotFoundError{})
   474  			})
   475  
   476  			It("returns a SharedServiceInstanceNotFoundError and all warnings", func() {
   477  				Expect(shareErr).To(MatchError(actionerror.SharedServiceInstanceNotFoundError{}))
   478  				Expect(warnings).To(ConsistOf("get-service-instance-warning"))
   479  			})
   480  		})
   481  	})
   482  
   483  	Describe("ShareServiceInstanceToSpaceNameByNameAndSpaceAndOrganizationName", func() {
   484  		var (
   485  			shareToSpaceName    string
   486  			serviceInstanceName string
   487  			sourceSpaceGUID     string
   488  			shareToOrgName      string
   489  
   490  			warnings Warnings
   491  			shareErr error
   492  		)
   493  
   494  		BeforeEach(func() {
   495  			shareToSpaceName = "some-space-name"
   496  			serviceInstanceName = "some-service-instance"
   497  			sourceSpaceGUID = "some-source-space-guid"
   498  			shareToOrgName = "some-org-name"
   499  		})
   500  
   501  		JustBeforeEach(func() {
   502  			warnings, shareErr = actor.ShareServiceInstanceToSpaceNameByNameAndSpaceAndOrganizationName(shareToSpaceName, serviceInstanceName, sourceSpaceGUID, shareToOrgName)
   503  		})
   504  
   505  		When("no errors occur getting the org", func() {
   506  			BeforeEach(func() {
   507  				fakeV3Actor.GetOrganizationByNameReturns(
   508  					v3action.Organization{
   509  						GUID: "some-org-guid",
   510  					},
   511  					v3action.Warnings{"get-org-warning"},
   512  					nil)
   513  
   514  				fakeV2Actor.GetServiceInstanceByNameAndSpaceReturns(
   515  					v2action.ServiceInstance{
   516  						GUID:        "some-service-instance-guid",
   517  						ServiceGUID: "some-service-guid",
   518  						Type:        constant.ManagedService,
   519  					},
   520  					v2action.Warnings{"get-service-instance-warning"},
   521  					nil)
   522  
   523  				fakeV2Actor.GetSpaceByOrganizationAndNameReturns(
   524  					v2action.Space{
   525  						GUID: "not-shared-space-guid",
   526  					},
   527  					v2action.Warnings{"get-space-warning"},
   528  					nil)
   529  
   530  				fakeV2Actor.GetServiceReturns(
   531  					v2action.Service{
   532  						Extra: ccv2.ServiceExtra{
   533  							Shareable: true,
   534  						},
   535  					},
   536  					v2action.Warnings{"get-service-warning"},
   537  					nil)
   538  
   539  				fakeV2Actor.GetFeatureFlagsReturns(
   540  					[]v2action.FeatureFlag{
   541  						{
   542  							Name:    "some-feature-flag",
   543  							Enabled: true,
   544  						},
   545  						{
   546  							Name:    "service_instance_sharing",
   547  							Enabled: true,
   548  						},
   549  					},
   550  					v2action.Warnings{"get-feature-flags-warning"},
   551  					nil)
   552  
   553  				fakeV2Actor.GetServiceInstanceSharedTosByServiceInstanceReturns(
   554  					[]v2action.ServiceInstanceSharedTo{
   555  						{SpaceGUID: "already-shared-space-guid-1"},
   556  						{SpaceGUID: "already-shared-space-guid-2"},
   557  					},
   558  					v2action.Warnings{"get-service-instance-shared-tos-warning"},
   559  					nil)
   560  
   561  				fakeV3Actor.ShareServiceInstanceToSpacesReturns(
   562  					resources.RelationshipList{
   563  						GUIDs: []string{"some-space-guid"},
   564  					},
   565  					v3action.Warnings{"share-service-instance-warning"},
   566  					nil)
   567  			})
   568  
   569  			It("shares the service instance to this space and returns all warnings", func() {
   570  				Expect(shareErr).ToNot(HaveOccurred())
   571  				Expect(warnings).To(ConsistOf(
   572  					"get-org-warning",
   573  					"get-service-instance-warning",
   574  					"get-space-warning",
   575  					"get-service-warning",
   576  					"get-feature-flags-warning",
   577  					"get-service-instance-shared-tos-warning",
   578  					"share-service-instance-warning"))
   579  
   580  				Expect(fakeV3Actor.GetOrganizationByNameCallCount()).To(Equal(1))
   581  				Expect(fakeV3Actor.GetOrganizationByNameArgsForCall(0)).To(Equal(shareToOrgName))
   582  
   583  				Expect(fakeV2Actor.GetServiceInstanceByNameAndSpaceCallCount()).To(Equal(1))
   584  				serviceInstanceNameArg, spaceGUIDArg := fakeV2Actor.GetServiceInstanceByNameAndSpaceArgsForCall(0)
   585  				Expect(serviceInstanceNameArg).To(Equal(serviceInstanceName))
   586  				Expect(spaceGUIDArg).To(Equal(sourceSpaceGUID))
   587  
   588  				Expect(fakeV2Actor.GetSpaceByOrganizationAndNameCallCount()).To(Equal(1))
   589  				orgGUIDArg, spaceNameArg := fakeV2Actor.GetSpaceByOrganizationAndNameArgsForCall(0)
   590  				Expect(orgGUIDArg).To(Equal("some-org-guid"))
   591  				Expect(spaceNameArg).To(Equal(shareToSpaceName))
   592  
   593  				Expect(fakeV2Actor.GetServiceCallCount()).To(Equal(1))
   594  				Expect(fakeV2Actor.GetServiceArgsForCall(0)).To(Equal("some-service-guid"))
   595  
   596  				Expect(fakeV2Actor.GetFeatureFlagsCallCount()).To(Equal(1))
   597  
   598  				Expect(fakeV2Actor.GetServiceInstanceSharedTosByServiceInstanceCallCount()).To(Equal(1))
   599  				Expect(fakeV2Actor.GetServiceInstanceSharedTosByServiceInstanceArgsForCall(0)).To(Equal("some-service-instance-guid"))
   600  
   601  				Expect(fakeV3Actor.ShareServiceInstanceToSpacesCallCount()).To(Equal(1))
   602  				serviceInstanceGUIDArg, spaceGUIDsArg := fakeV3Actor.ShareServiceInstanceToSpacesArgsForCall(0)
   603  				Expect(serviceInstanceGUIDArg).To(Equal("some-service-instance-guid"))
   604  				Expect(spaceGUIDsArg).To(Equal([]string{"not-shared-space-guid"}))
   605  			})
   606  		})
   607  
   608  		When("an error occurs getting the org", func() {
   609  			var expectedErr error
   610  
   611  			BeforeEach(func() {
   612  				expectedErr = errors.New("get org error")
   613  				fakeV3Actor.GetOrganizationByNameReturns(
   614  					v3action.Organization{},
   615  					v3action.Warnings{"get-org-warning"},
   616  					expectedErr)
   617  			})
   618  
   619  			It("returns the error and all warnings", func() {
   620  				Expect(shareErr).To(MatchError(expectedErr))
   621  				Expect(warnings).To(ConsistOf("get-org-warning"))
   622  			})
   623  		})
   624  	})
   625  
   626  	Describe("UnshareServiceInstanceFromOrganizationNameAndSpaceNameByNameAndSpace", func() {
   627  		var (
   628  			shareToOrgName             string
   629  			shareToSpaceName           string
   630  			serviceInstanceName        string
   631  			currentlyTargetedSpaceGUID string
   632  
   633  			warnings   Warnings
   634  			executeErr error
   635  		)
   636  
   637  		BeforeEach(func() {
   638  			shareToOrgName = "shared-to-org"
   639  			shareToSpaceName = "shared-to-space"
   640  			serviceInstanceName = "some-service-instance"
   641  			currentlyTargetedSpaceGUID = "currently-targeted-space-guid"
   642  		})
   643  
   644  		JustBeforeEach(func() {
   645  			warnings, executeErr = actor.UnshareServiceInstanceFromOrganizationNameAndSpaceNameByNameAndSpace(shareToOrgName, shareToSpaceName, serviceInstanceName, currentlyTargetedSpaceGUID)
   646  		})
   647  
   648  		When("no errors occur getting the service instance", func() {
   649  			BeforeEach(func() {
   650  				fakeV2Actor.GetServiceInstanceByNameAndSpaceReturns(
   651  					v2action.ServiceInstance{
   652  						GUID: "some-service-instance-guid",
   653  					},
   654  					v2action.Warnings{"get-service-instance-warning"},
   655  					nil)
   656  			})
   657  
   658  			When("no errors occur getting the service instance's shared to spaces", func() {
   659  				BeforeEach(func() {
   660  					fakeV2Actor.GetServiceInstanceSharedTosByServiceInstanceReturns(
   661  						[]v2action.ServiceInstanceSharedTo{
   662  							{
   663  								SpaceGUID:        "some-other-shared-to-space-guid",
   664  								SpaceName:        "some-other-shared-to-space",
   665  								OrganizationName: "some-other-shared-to-org",
   666  							},
   667  							{
   668  								SpaceGUID:        "shared-to-space-guid",
   669  								SpaceName:        "shared-to-space",
   670  								OrganizationName: "shared-to-org",
   671  							},
   672  						},
   673  						v2action.Warnings{"get-shared-tos-warning"},
   674  						nil)
   675  				})
   676  
   677  				When("no errors occur unsharing the service instance", func() {
   678  					BeforeEach(func() {
   679  						fakeV3Actor.UnshareServiceInstanceByServiceInstanceAndSpaceReturns(
   680  							v3action.Warnings{"unshare-warning"},
   681  							nil)
   682  					})
   683  
   684  					It("returns no errors and returns all warnings", func() {
   685  						Expect(executeErr).ToNot(HaveOccurred())
   686  						Expect(warnings).To(ConsistOf(
   687  							"get-service-instance-warning",
   688  							"get-shared-tos-warning",
   689  							"unshare-warning"))
   690  
   691  						Expect(fakeV2Actor.GetServiceInstanceByNameAndSpaceCallCount()).To(Equal(1))
   692  						serviceInstanceNameArg, spaceGUIDArg := fakeV2Actor.GetServiceInstanceByNameAndSpaceArgsForCall(0)
   693  						Expect(serviceInstanceNameArg).To(Equal(serviceInstanceName))
   694  						Expect(spaceGUIDArg).To(Equal(currentlyTargetedSpaceGUID))
   695  
   696  						Expect(fakeV2Actor.GetServiceInstanceSharedTosByServiceInstanceCallCount()).To(Equal(1))
   697  						Expect(fakeV2Actor.GetServiceInstanceSharedTosByServiceInstanceArgsForCall(0)).To(Equal("some-service-instance-guid"))
   698  
   699  						Expect(fakeV3Actor.UnshareServiceInstanceByServiceInstanceAndSpaceCallCount()).To(Equal(1))
   700  						serviceInstanceGUIDArg, spaceGUIDArg := fakeV3Actor.UnshareServiceInstanceByServiceInstanceAndSpaceArgsForCall(0)
   701  						Expect(serviceInstanceGUIDArg).To(Equal("some-service-instance-guid"))
   702  						Expect(spaceGUIDArg).To(Equal("shared-to-space-guid"))
   703  					})
   704  				})
   705  
   706  				When("an error occurs unsharing the service instance", func() {
   707  					var expectedErr error
   708  
   709  					BeforeEach(func() {
   710  						expectedErr = errors.New("unshare error")
   711  						fakeV3Actor.UnshareServiceInstanceByServiceInstanceAndSpaceReturns(
   712  							v3action.Warnings{"unshare-warning"},
   713  							expectedErr)
   714  					})
   715  
   716  					It("returns the error and all warnings", func() {
   717  						Expect(executeErr).To(MatchError(expectedErr))
   718  						Expect(warnings).To(ConsistOf(
   719  							"get-service-instance-warning",
   720  							"get-shared-tos-warning",
   721  							"unshare-warning"))
   722  					})
   723  				})
   724  			})
   725  
   726  			When("an error occurs getting the service instance's shared to spaces", func() {
   727  				var expectedErr error
   728  
   729  				BeforeEach(func() {
   730  					expectedErr = errors.New("get shared tos error")
   731  					fakeV2Actor.GetServiceInstanceSharedTosByServiceInstanceReturns(
   732  						nil,
   733  						v2action.Warnings{"get-shared-tos-warning"},
   734  						expectedErr)
   735  				})
   736  
   737  				It("returns the error and all warnings", func() {
   738  					Expect(executeErr).To(MatchError(expectedErr))
   739  					Expect(warnings).To(ConsistOf(
   740  						"get-service-instance-warning",
   741  						"get-shared-tos-warning"))
   742  				})
   743  			})
   744  
   745  			When("the service instance is not shared to the space we want to unshare with", func() {
   746  				BeforeEach(func() {
   747  					fakeV2Actor.GetServiceInstanceSharedTosByServiceInstanceReturns(
   748  						[]v2action.ServiceInstanceSharedTo{
   749  							{
   750  								SpaceGUID:        "some-other-shared-to-space-guid",
   751  								SpaceName:        "some-other-shared-to-space",
   752  								OrganizationName: "some-other-shared-to-org",
   753  							},
   754  						},
   755  						v2action.Warnings{"get-shared-tos-warning"},
   756  						nil)
   757  				})
   758  
   759  				It("returns a ServiceInstanceNotSharedToSpaceError and all warnings", func() {
   760  					Expect(executeErr).To(MatchError(actionerror.ServiceInstanceNotSharedToSpaceError{
   761  						ServiceInstanceName: "some-service-instance",
   762  					}))
   763  					Expect(warnings).To(ConsistOf(
   764  						"get-service-instance-warning",
   765  						"get-shared-tos-warning"))
   766  				})
   767  			})
   768  		})
   769  
   770  		When("an error occurs getting the service instance", func() {
   771  			var expectedErr error
   772  
   773  			BeforeEach(func() {
   774  				expectedErr = errors.New("get service instance error")
   775  				fakeV2Actor.GetServiceInstanceByNameAndSpaceReturns(
   776  					v2action.ServiceInstance{},
   777  					v2action.Warnings{"get-service-instance-warning"},
   778  					expectedErr)
   779  			})
   780  
   781  			It("returns the error and all warnings", func() {
   782  				Expect(executeErr).To(MatchError(expectedErr))
   783  				Expect(warnings).To(ConsistOf("get-service-instance-warning"))
   784  			})
   785  		})
   786  
   787  		When("the service instance does not exist", func() {
   788  			BeforeEach(func() {
   789  				fakeV2Actor.GetServiceInstanceByNameAndSpaceReturns(
   790  					v2action.ServiceInstance{},
   791  					v2action.Warnings{"get-service-instance-warning"},
   792  					actionerror.ServiceInstanceNotFoundError{})
   793  			})
   794  
   795  			It("returns a SharedServiceInstanceNotFoundError and all warnings", func() {
   796  				Expect(executeErr).To(MatchError(actionerror.SharedServiceInstanceNotFoundError{}))
   797  				Expect(warnings).To(ConsistOf("get-service-instance-warning"))
   798  			})
   799  		})
   800  	})
   801  })