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