github.com/franc20/ayesa_sap@v7.0.0-beta.28.0.20200124003224-302d4d52fa6c+incompatible/actor/v7action/role_test.go (about)

     1  package v7action_test
     2  
     3  import (
     4  	"errors"
     5  
     6  	"code.cloudfoundry.org/cli/actor/actionerror"
     7  	. "code.cloudfoundry.org/cli/actor/v7action"
     8  	"code.cloudfoundry.org/cli/actor/v7action/v7actionfakes"
     9  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccerror"
    10  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3"
    11  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3/constant"
    12  	. "github.com/onsi/ginkgo"
    13  	. "github.com/onsi/gomega"
    14  )
    15  
    16  var _ = Describe("Role Actions", func() {
    17  	var (
    18  		actor                     *Actor
    19  		fakeCloudControllerClient *v7actionfakes.FakeCloudControllerClient
    20  		fakeUAAClient             *v7actionfakes.FakeUAAClient
    21  	)
    22  
    23  	BeforeEach(func() {
    24  		actor, fakeCloudControllerClient, _, _, fakeUAAClient, _ = NewTestActor()
    25  	})
    26  
    27  	Describe("CreateOrgRole", func() {
    28  		var (
    29  			roleType       constant.RoleType
    30  			userNameOrGUID string
    31  			userOrigin     string
    32  			orgGUID        string
    33  			isClient       bool
    34  
    35  			warnings   Warnings
    36  			executeErr error
    37  		)
    38  
    39  		BeforeEach(func() {
    40  			roleType = constant.OrgAuditorRole
    41  			orgGUID = "org-guid"
    42  		})
    43  
    44  		JustBeforeEach(func() {
    45  			warnings, executeErr = actor.CreateOrgRole(roleType, orgGUID, userNameOrGUID, userOrigin, isClient)
    46  		})
    47  
    48  		When("creating the role succeeds", func() {
    49  			BeforeEach(func() {
    50  				fakeCloudControllerClient.CreateRoleReturns(
    51  					ccv3.Role{
    52  						Type:     roleType,
    53  						UserGUID: "user-guid",
    54  						OrgGUID:  "org-guid",
    55  					},
    56  					ccv3.Warnings{"create-role-warning"},
    57  					nil,
    58  				)
    59  			})
    60  
    61  			When("creating a role for a client", func() {
    62  				BeforeEach(func() {
    63  					userNameOrGUID = "user-guid"
    64  					userOrigin = ""
    65  					isClient = true
    66  				})
    67  
    68  				It("returns the role and any warnings", func() {
    69  					Expect(warnings).To(ConsistOf("create-role-warning"))
    70  					Expect(executeErr).ToNot(HaveOccurred())
    71  
    72  					Expect(fakeCloudControllerClient.CreateRoleCallCount()).To(Equal(1))
    73  					passedRole := fakeCloudControllerClient.CreateRoleArgsForCall(0)
    74  
    75  					Expect(passedRole).To(Equal(
    76  						ccv3.Role{
    77  							Type:     roleType,
    78  							UserGUID: "user-guid",
    79  							OrgGUID:  "org-guid",
    80  						},
    81  					))
    82  				})
    83  
    84  				When("the client does not exist in UAA", func() {
    85  					BeforeEach(func() {
    86  						fakeUAAClient.ValidateClientUserReturns(actionerror.UserNotFoundError{Username: "bad-client"})
    87  					})
    88  
    89  					It("returns the error", func() {
    90  						Expect(warnings).To(BeEmpty())
    91  						Expect(executeErr).To(MatchError(actionerror.UserNotFoundError{Username: "bad-client"}))
    92  					})
    93  				})
    94  			})
    95  
    96  			When("creating a role for a non-client user", func() {
    97  				BeforeEach(func() {
    98  					userNameOrGUID = "user-name"
    99  					userOrigin = "user-origin"
   100  					isClient = false
   101  				})
   102  
   103  				It("returns the role and any warnings", func() {
   104  					Expect(warnings).To(ConsistOf("create-role-warning"))
   105  					Expect(executeErr).ToNot(HaveOccurred())
   106  
   107  					Expect(fakeCloudControllerClient.CreateRoleCallCount()).To(Equal(1))
   108  					passedRole := fakeCloudControllerClient.CreateRoleArgsForCall(0)
   109  
   110  					Expect(passedRole).To(Equal(
   111  						ccv3.Role{
   112  							Type:     roleType,
   113  							Username: "user-name",
   114  							Origin:   "user-origin",
   115  							OrgGUID:  "org-guid",
   116  						},
   117  					))
   118  				})
   119  			})
   120  		})
   121  
   122  		When("the API call to create the role returns an error", func() {
   123  			BeforeEach(func() {
   124  				fakeCloudControllerClient.CreateRoleReturns(
   125  					ccv3.Role{},
   126  					ccv3.Warnings{"create-role-warning"},
   127  					errors.New("create-role-error"),
   128  				)
   129  			})
   130  
   131  			It("it returns an error and warnings", func() {
   132  				Expect(fakeCloudControllerClient.CreateRoleCallCount()).To(Equal(1))
   133  				Expect(warnings).To(ConsistOf("create-role-warning"))
   134  				Expect(executeErr).To(MatchError("create-role-error"))
   135  			})
   136  		})
   137  	})
   138  
   139  	Describe("CreateSpaceRole", func() {
   140  		var (
   141  			roleType       constant.RoleType
   142  			userNameOrGUID string
   143  			userOrigin     string
   144  			orgGUID        string
   145  			spaceGUID      string
   146  			isClient       bool
   147  
   148  			warnings   Warnings
   149  			executeErr error
   150  		)
   151  
   152  		BeforeEach(func() {
   153  			roleType = constant.SpaceDeveloperRole
   154  			orgGUID = "org-guid"
   155  			spaceGUID = "space-guid"
   156  		})
   157  
   158  		JustBeforeEach(func() {
   159  			warnings, executeErr = actor.CreateSpaceRole(roleType, orgGUID, spaceGUID, userNameOrGUID, userOrigin, isClient)
   160  		})
   161  
   162  		When("creating the role succeeds", func() {
   163  			BeforeEach(func() {
   164  				fakeCloudControllerClient.CreateRoleReturnsOnCall(0,
   165  					ccv3.Role{
   166  						Type:     constant.OrgUserRole,
   167  						UserGUID: "user-guid",
   168  						OrgGUID:  "org-guid",
   169  					},
   170  					ccv3.Warnings{"create-org-role-warning"},
   171  					nil,
   172  				)
   173  
   174  				fakeCloudControllerClient.CreateRoleReturnsOnCall(1,
   175  					ccv3.Role{
   176  						Type:      roleType,
   177  						UserGUID:  "user-guid",
   178  						SpaceGUID: "space-guid",
   179  					},
   180  					ccv3.Warnings{"create-space-role-warning"},
   181  					nil,
   182  				)
   183  			})
   184  
   185  			When("creating a space role for a client", func() {
   186  				BeforeEach(func() {
   187  					userNameOrGUID = "user-guid"
   188  					userOrigin = ""
   189  					isClient = true
   190  				})
   191  
   192  				It("returns the role and any warnings", func() {
   193  					Expect(warnings).To(ConsistOf("create-org-role-warning", "create-space-role-warning"))
   194  					Expect(executeErr).ToNot(HaveOccurred())
   195  
   196  					Expect(fakeCloudControllerClient.CreateRoleCallCount()).To(Equal(2))
   197  
   198  					passedOrgRole := fakeCloudControllerClient.CreateRoleArgsForCall(0)
   199  					Expect(passedOrgRole).To(Equal(
   200  						ccv3.Role{
   201  							Type:     constant.OrgUserRole,
   202  							UserGUID: "user-guid",
   203  							OrgGUID:  "org-guid",
   204  						},
   205  					))
   206  
   207  					passedSpaceRole := fakeCloudControllerClient.CreateRoleArgsForCall(1)
   208  					Expect(passedSpaceRole).To(Equal(
   209  						ccv3.Role{
   210  							Type:      roleType,
   211  							UserGUID:  "user-guid",
   212  							SpaceGUID: "space-guid",
   213  						},
   214  					))
   215  				})
   216  			})
   217  
   218  			When("creating a space role for a non-client user", func() {
   219  				BeforeEach(func() {
   220  					userNameOrGUID = "user-name"
   221  					userOrigin = "user-origin"
   222  					isClient = false
   223  				})
   224  
   225  				It("returns the role and any warnings", func() {
   226  					Expect(warnings).To(ConsistOf("create-org-role-warning", "create-space-role-warning"))
   227  					Expect(executeErr).ToNot(HaveOccurred())
   228  
   229  					Expect(fakeCloudControllerClient.CreateRoleCallCount()).To(Equal(2))
   230  
   231  					passedOrgRole := fakeCloudControllerClient.CreateRoleArgsForCall(0)
   232  					Expect(passedOrgRole).To(Equal(
   233  						ccv3.Role{
   234  							Type:     constant.OrgUserRole,
   235  							Username: "user-name",
   236  							Origin:   "user-origin",
   237  							OrgGUID:  "org-guid",
   238  						},
   239  					))
   240  
   241  					passedSpaceRole := fakeCloudControllerClient.CreateRoleArgsForCall(1)
   242  					Expect(passedSpaceRole).To(Equal(
   243  						ccv3.Role{
   244  							Type:      roleType,
   245  							Username:  "user-name",
   246  							Origin:    "user-origin",
   247  							SpaceGUID: "space-guid",
   248  						},
   249  					))
   250  				})
   251  			})
   252  		})
   253  
   254  		When("the user already has an org role", func() {
   255  			BeforeEach(func() {
   256  				fakeCloudControllerClient.CreateRoleReturnsOnCall(0,
   257  					ccv3.Role{},
   258  					ccv3.Warnings{"create-org-role-warning"},
   259  					ccerror.RoleAlreadyExistsError{},
   260  				)
   261  			})
   262  
   263  			It("it ignores the error and creates the space role", func() {
   264  				Expect(fakeCloudControllerClient.CreateRoleCallCount()).To(Equal(2))
   265  				Expect(warnings).To(ConsistOf("create-org-role-warning"))
   266  				Expect(executeErr).NotTo(HaveOccurred())
   267  			})
   268  		})
   269  
   270  		When("the client does not exist in UAA", func() {
   271  			BeforeEach(func() {
   272  				fakeUAAClient.ValidateClientUserReturns(actionerror.UserNotFoundError{Username: "bad-client"})
   273  			})
   274  
   275  			It("returns the error", func() {
   276  				Expect(warnings).To(BeEmpty())
   277  				Expect(executeErr).NotTo(HaveOccurred())
   278  			})
   279  		})
   280  
   281  		When("the API call to create the org role returns an error", func() {
   282  			Context("and it is not a forbidden", func() {
   283  				BeforeEach(func() {
   284  					fakeCloudControllerClient.CreateRoleReturnsOnCall(0,
   285  						ccv3.Role{},
   286  						ccv3.Warnings{"create-org-role-warning"},
   287  						errors.New("create-org-role-error"),
   288  					)
   289  				})
   290  
   291  				It("it returns an error and warnings", func() {
   292  					Expect(fakeCloudControllerClient.CreateRoleCallCount()).To(Equal(1))
   293  					Expect(warnings).To(ConsistOf("create-org-role-warning"))
   294  					Expect(executeErr).To(MatchError("create-org-role-error"))
   295  				})
   296  			})
   297  
   298  			Context("and it is a forbidden", func() {
   299  				BeforeEach(func() {
   300  					fakeCloudControllerClient.CreateRoleReturnsOnCall(0,
   301  						ccv3.Role{},
   302  						ccv3.Warnings{"create-org-role-warning"},
   303  						ccerror.ForbiddenError{Message: "create-org-role-forbidden-error"},
   304  					)
   305  					fakeCloudControllerClient.CreateRoleReturnsOnCall(1,
   306  						ccv3.Role{},
   307  						ccv3.Warnings{"create-space-role-warning"},
   308  						ccerror.ForbiddenError{Message: "create-space-role-forbidden-error"},
   309  					)
   310  				})
   311  
   312  				It("it continues to make the call to API create space and returns the more helpful errors and warnings", func() {
   313  					Expect(fakeCloudControllerClient.CreateRoleCallCount()).To(Equal(2))
   314  					Expect(warnings).To(ConsistOf("create-space-role-warning", "create-org-role-warning"))
   315  					Expect(executeErr).To(MatchError("create-space-role-forbidden-error"))
   316  				})
   317  			})
   318  		})
   319  
   320  		When("the API call to create the space role returns an error", func() {
   321  			BeforeEach(func() {
   322  				fakeCloudControllerClient.CreateRoleReturnsOnCall(1,
   323  					ccv3.Role{},
   324  					ccv3.Warnings{"create-space-role-warning"},
   325  					errors.New("create-space-role-error"),
   326  				)
   327  			})
   328  
   329  			It("it returns an error and warnings", func() {
   330  				Expect(fakeCloudControllerClient.CreateRoleCallCount()).To(Equal(2))
   331  				Expect(warnings).To(ConsistOf("create-space-role-warning"))
   332  				Expect(executeErr).To(MatchError("create-space-role-error"))
   333  			})
   334  		})
   335  	})
   336  
   337  	Describe("DeleteSpaceRole", func() {
   338  		var (
   339  			roleType       constant.RoleType
   340  			userNameOrGUID string
   341  			userOrigin     string
   342  			spaceGUID      string
   343  			isClient       bool
   344  
   345  			warnings   Warnings
   346  			executeErr error
   347  		)
   348  
   349  		BeforeEach(func() {
   350  			roleType = constant.SpaceDeveloperRole
   351  			spaceGUID = "space-guid"
   352  			isClient = false
   353  		})
   354  
   355  		JustBeforeEach(func() {
   356  			warnings, executeErr = actor.DeleteSpaceRole(roleType, spaceGUID, userNameOrGUID, userOrigin, isClient)
   357  		})
   358  
   359  		When("deleting a role succeeds", func() {
   360  			BeforeEach(func() {
   361  				fakeCloudControllerClient.GetUsersReturnsOnCall(0,
   362  					[]ccv3.User{{Username: userNameOrGUID, GUID: "user-guid"}},
   363  					ccv3.Warnings{"get-users-warning"},
   364  					nil,
   365  				)
   366  
   367  				fakeCloudControllerClient.GetUserReturnsOnCall(0,
   368  					ccv3.User{GUID: "user-guid"},
   369  					ccv3.Warnings{"get-user-warning"},
   370  					nil,
   371  				)
   372  
   373  				fakeCloudControllerClient.GetRolesReturnsOnCall(0,
   374  					[]ccv3.Role{
   375  						{
   376  							GUID:      "role-guid",
   377  							Type:      roleType,
   378  							UserGUID:  "user-guid",
   379  							SpaceGUID: spaceGUID,
   380  						},
   381  					},
   382  					ccv3.IncludedResources{},
   383  					ccv3.Warnings{"get-roles-warning"},
   384  					nil,
   385  				)
   386  
   387  				fakeCloudControllerClient.DeleteRoleReturnsOnCall(0,
   388  					ccv3.JobURL("https://jobs/job_guid"),
   389  					ccv3.Warnings{"delete-role-warning"},
   390  					nil,
   391  				)
   392  
   393  				fakeCloudControllerClient.PollJobReturnsOnCall(0,
   394  					ccv3.Warnings{"poll-job-warning"},
   395  					nil,
   396  				)
   397  
   398  			})
   399  
   400  			When("deleting a space role for a client", func() {
   401  				BeforeEach(func() {
   402  					userNameOrGUID = "user-guid"
   403  					userOrigin = ""
   404  					isClient = true
   405  				})
   406  
   407  				It("delete the role and returns any warnings", func() {
   408  					Expect(warnings).To(ConsistOf("get-user-warning", "get-roles-warning", "delete-role-warning", "poll-job-warning"))
   409  					Expect(executeErr).ToNot(HaveOccurred())
   410  
   411  					Expect(fakeCloudControllerClient.GetUserCallCount()).To(Equal(1))
   412  
   413  					passedGuid := fakeCloudControllerClient.GetUserArgsForCall(0)
   414  					Expect(passedGuid).To(Equal(userNameOrGUID))
   415  
   416  					passedRolesQuery := fakeCloudControllerClient.GetRolesArgsForCall(0)
   417  					Expect(passedRolesQuery).To(Equal(
   418  						[]ccv3.Query{
   419  							{
   420  								Key:    ccv3.UserGUIDFilter,
   421  								Values: []string{userNameOrGUID},
   422  							},
   423  							{
   424  								Key:    ccv3.RoleTypesFilter,
   425  								Values: []string{string(constant.SpaceDeveloperRole)},
   426  							},
   427  							{
   428  								Key:    ccv3.SpaceGUIDFilter,
   429  								Values: []string{spaceGUID},
   430  							},
   431  						},
   432  					))
   433  					passedRoleGUID := fakeCloudControllerClient.DeleteRoleArgsForCall(0)
   434  					Expect(passedRoleGUID).To(Equal("role-guid"))
   435  
   436  					passedJobURL := fakeCloudControllerClient.PollJobArgsForCall(0)
   437  					Expect(passedJobURL).To(Equal(ccv3.JobURL("https://jobs/job_guid")))
   438  				})
   439  
   440  			})
   441  
   442  			When("deleting a space role for a non-client user", func() {
   443  				BeforeEach(func() {
   444  					userNameOrGUID = "user-name"
   445  					userOrigin = "user-origin"
   446  					isClient = false
   447  				})
   448  
   449  				It("deletes the role and returns any warnings", func() {
   450  					Expect(warnings).To(ConsistOf("get-users-warning", "get-roles-warning", "delete-role-warning", "poll-job-warning"))
   451  					Expect(executeErr).ToNot(HaveOccurred())
   452  
   453  					passedQuery := fakeCloudControllerClient.GetUsersArgsForCall(0)
   454  					Expect(passedQuery).To(Equal(
   455  						[]ccv3.Query{
   456  							{
   457  								Key:    ccv3.UsernamesFilter,
   458  								Values: []string{userNameOrGUID},
   459  							},
   460  							{
   461  								Key:    ccv3.OriginsFilter,
   462  								Values: []string{userOrigin},
   463  							},
   464  						},
   465  					))
   466  
   467  					passedRolesQuery := fakeCloudControllerClient.GetRolesArgsForCall(0)
   468  					Expect(passedRolesQuery).To(Equal(
   469  						[]ccv3.Query{
   470  							{
   471  								Key:    ccv3.UserGUIDFilter,
   472  								Values: []string{"user-guid"},
   473  							},
   474  							{
   475  								Key:    ccv3.RoleTypesFilter,
   476  								Values: []string{string(constant.SpaceDeveloperRole)},
   477  							},
   478  							{
   479  								Key:    ccv3.SpaceGUIDFilter,
   480  								Values: []string{spaceGUID},
   481  							},
   482  						},
   483  					))
   484  
   485  					passedRoleGUID := fakeCloudControllerClient.DeleteRoleArgsForCall(0)
   486  					Expect(passedRoleGUID).To(Equal("role-guid"))
   487  
   488  					passedJobURL := fakeCloudControllerClient.PollJobArgsForCall(0)
   489  					Expect(passedJobURL).To(Equal(ccv3.JobURL("https://jobs/job_guid")))
   490  				})
   491  			})
   492  		})
   493  
   494  		When("the user does not have the space role to delete", func() {
   495  			BeforeEach(func() {
   496  				fakeCloudControllerClient.GetUsersReturnsOnCall(0,
   497  					[]ccv3.User{{Username: userNameOrGUID, GUID: "user-guid"}},
   498  					ccv3.Warnings{"get-users-warning"},
   499  					nil,
   500  				)
   501  
   502  				fakeCloudControllerClient.GetRolesReturnsOnCall(0,
   503  					[]ccv3.Role{},
   504  					ccv3.IncludedResources{},
   505  					ccv3.Warnings{"get-roles-warning"},
   506  					nil,
   507  				)
   508  
   509  			})
   510  
   511  			It("it gets an empty list of roles and exits after the request", func() {
   512  				Expect(fakeCloudControllerClient.GetUsersCallCount()).To(Equal(1))
   513  				Expect(fakeCloudControllerClient.GetRolesCallCount()).To(Equal(1))
   514  				Expect(fakeCloudControllerClient.DeleteRoleCallCount()).To(Equal(0))
   515  				Expect(fakeCloudControllerClient.PollJobCallCount()).To(Equal(0))
   516  
   517  				Expect(warnings).To(ConsistOf("get-users-warning", "get-roles-warning"))
   518  				Expect(executeErr).NotTo(HaveOccurred())
   519  			})
   520  		})
   521  
   522  		Context("the user is not found", func() {
   523  			When("The user is not a client", func() {
   524  				BeforeEach(func() {
   525  					fakeCloudControllerClient.GetUsersReturnsOnCall(0,
   526  						[]ccv3.User{},
   527  						ccv3.Warnings{"get-users-warning"},
   528  						nil,
   529  					)
   530  				})
   531  				It("returns a user not found error and warnings", func() {
   532  					Expect(fakeCloudControllerClient.GetUsersCallCount()).To(Equal(1))
   533  					passedQuery := fakeCloudControllerClient.GetUsersArgsForCall(0)
   534  					Expect(passedQuery).To(Equal(
   535  						[]ccv3.Query{
   536  							{
   537  								Key:    ccv3.UsernamesFilter,
   538  								Values: []string{userNameOrGUID},
   539  							},
   540  							{
   541  								Key:    ccv3.OriginsFilter,
   542  								Values: []string{userOrigin},
   543  							},
   544  						},
   545  					))
   546  					Expect(fakeCloudControllerClient.GetRolesCallCount()).To(Equal(0))
   547  					Expect(fakeCloudControllerClient.DeleteRoleCallCount()).To(Equal(0))
   548  					Expect(fakeCloudControllerClient.PollJobCallCount()).To(Equal(0))
   549  
   550  					Expect(executeErr).To(MatchError(actionerror.UserNotFoundError{Username: userNameOrGUID, Origin: userOrigin}))
   551  				})
   552  			})
   553  
   554  			When("The user is a client", func() {
   555  				BeforeEach(func() {
   556  					userNameOrGUID = "user-guid"
   557  					userOrigin = ""
   558  					isClient = true
   559  					fakeCloudControllerClient.GetUserReturnsOnCall(0,
   560  						ccv3.User{},
   561  						ccv3.Warnings{"get-users-warning"},
   562  						ccerror.UserNotFoundError{},
   563  					)
   564  				})
   565  
   566  				It("returns a user not found error and warnings", func() {
   567  					Expect(fakeCloudControllerClient.GetUserCallCount()).To(Equal(1))
   568  					guid := fakeCloudControllerClient.GetUserArgsForCall(0)
   569  					Expect(guid).To(Equal(userNameOrGUID))
   570  					Expect(fakeCloudControllerClient.GetRolesCallCount()).To(Equal(0))
   571  					Expect(fakeCloudControllerClient.DeleteRoleCallCount()).To(Equal(0))
   572  					Expect(fakeCloudControllerClient.PollJobCallCount()).To(Equal(0))
   573  
   574  					Expect(executeErr).To(MatchError(actionerror.UserNotFoundError{Username: userNameOrGUID}))
   575  				})
   576  			})
   577  		})
   578  
   579  		When("the API call to delete the space role returns an error", func() {
   580  			BeforeEach(func() {
   581  				fakeCloudControllerClient.GetUsersReturnsOnCall(0,
   582  					[]ccv3.User{{Username: userNameOrGUID, GUID: "user-guid"}},
   583  					ccv3.Warnings{"get-users-warning"},
   584  					nil,
   585  				)
   586  
   587  				fakeCloudControllerClient.GetRolesReturnsOnCall(0,
   588  					[]ccv3.Role{
   589  						{
   590  							GUID:      "role-guid",
   591  							Type:      roleType,
   592  							UserGUID:  "user-guid",
   593  							SpaceGUID: spaceGUID,
   594  						},
   595  					},
   596  					ccv3.IncludedResources{},
   597  					ccv3.Warnings{"get-roles-warning"},
   598  					nil,
   599  				)
   600  
   601  				fakeCloudControllerClient.DeleteRoleReturnsOnCall(0,
   602  					ccv3.JobURL(""),
   603  					ccv3.Warnings{"delete-space-role-warning"},
   604  					errors.New("delete-space-role-error"),
   605  				)
   606  			})
   607  
   608  			It("it returns an error and warnings", func() {
   609  				Expect(fakeCloudControllerClient.DeleteRoleCallCount()).To(Equal(1))
   610  				Expect(executeErr).To(MatchError("delete-space-role-error"))
   611  				Expect(warnings).To(ConsistOf("get-users-warning", "get-roles-warning", "delete-space-role-warning"))
   612  			})
   613  		})
   614  	})
   615  
   616  	Describe("GetRoleGUID", func() {
   617  		var (
   618  			roleType       constant.RoleType
   619  			userGUID       string
   620  			orgOrSpaceGUID string
   621  			roleGUID       string
   622  			queryKey       ccv3.QueryKey
   623  
   624  			warnings   Warnings
   625  			executeErr error
   626  		)
   627  
   628  		BeforeEach(func() {
   629  			roleType = constant.SpaceDeveloperRole
   630  			queryKey = ccv3.SpaceGUIDFilter
   631  			orgOrSpaceGUID = "space-guid"
   632  			userGUID = "user-guid"
   633  		})
   634  
   635  		JustBeforeEach(func() {
   636  			roleGUID, warnings, executeErr = actor.GetRoleGUID(queryKey, orgOrSpaceGUID, userGUID, roleType)
   637  		})
   638  
   639  		When("the role exists and no errors occur", func() {
   640  
   641  			When("the role is a space role", func() {
   642  				BeforeEach(func() {
   643  					fakeCloudControllerClient.GetRolesReturnsOnCall(0,
   644  						[]ccv3.Role{
   645  							{
   646  								GUID:      "role-guid",
   647  								Type:      roleType,
   648  								UserGUID:  userGUID,
   649  								SpaceGUID: orgOrSpaceGUID,
   650  							},
   651  						},
   652  						ccv3.IncludedResources{},
   653  						ccv3.Warnings{"get-roles-warning"},
   654  						nil,
   655  					)
   656  				})
   657  				It("it gets role guid and no errors", func() {
   658  					passedRolesQuery := fakeCloudControllerClient.GetRolesArgsForCall(0)
   659  					Expect(passedRolesQuery).To(Equal(
   660  						[]ccv3.Query{
   661  							{
   662  								Key:    ccv3.UserGUIDFilter,
   663  								Values: []string{userGUID},
   664  							},
   665  							{
   666  								Key:    ccv3.RoleTypesFilter,
   667  								Values: []string{string(constant.SpaceDeveloperRole)},
   668  							},
   669  							{
   670  								Key:    ccv3.SpaceGUIDFilter,
   671  								Values: []string{orgOrSpaceGUID},
   672  							},
   673  						},
   674  					))
   675  					Expect(warnings).To(ConsistOf("get-roles-warning"))
   676  					Expect(executeErr).NotTo(HaveOccurred())
   677  					Expect(roleGUID).To(Equal("role-guid"))
   678  				})
   679  			})
   680  			When("the role is an org role", func() {
   681  				BeforeEach(func() {
   682  					orgOrSpaceGUID = "org-guid"
   683  					queryKey = ccv3.OrganizationGUIDFilter
   684  					fakeCloudControllerClient.GetRolesReturnsOnCall(0,
   685  						[]ccv3.Role{
   686  							{
   687  								GUID:     "role-guid",
   688  								Type:     roleType,
   689  								UserGUID: userGUID,
   690  								OrgGUID:  orgOrSpaceGUID,
   691  							},
   692  						},
   693  						ccv3.IncludedResources{},
   694  						ccv3.Warnings{"get-roles-warning"},
   695  						nil,
   696  					)
   697  				})
   698  				It("it gets role guid and no errors", func() {
   699  					passedRolesQuery := fakeCloudControllerClient.GetRolesArgsForCall(0)
   700  					Expect(passedRolesQuery).To(Equal(
   701  						[]ccv3.Query{
   702  							{
   703  								Key:    ccv3.UserGUIDFilter,
   704  								Values: []string{userGUID},
   705  							},
   706  							{
   707  								Key:    ccv3.RoleTypesFilter,
   708  								Values: []string{string(constant.SpaceDeveloperRole)},
   709  							},
   710  							{
   711  								Key:    ccv3.OrganizationGUIDFilter,
   712  								Values: []string{orgOrSpaceGUID},
   713  							},
   714  						},
   715  					))
   716  					Expect(warnings).To(ConsistOf("get-roles-warning"))
   717  					Expect(executeErr).NotTo(HaveOccurred())
   718  					Expect(roleGUID).To(Equal("role-guid"))
   719  				})
   720  			})
   721  		})
   722  
   723  		When("the role does not exist and no errors occur", func() {
   724  			BeforeEach(func() {
   725  				fakeCloudControllerClient.GetRolesReturnsOnCall(0,
   726  					[]ccv3.Role{},
   727  					ccv3.IncludedResources{},
   728  					ccv3.Warnings{"get-roles-warning"},
   729  					nil,
   730  				)
   731  			})
   732  			It("it gets an empty string and no errors", func() {
   733  				passedRolesQuery := fakeCloudControllerClient.GetRolesArgsForCall(0)
   734  				Expect(passedRolesQuery).To(Equal(
   735  					[]ccv3.Query{
   736  						{
   737  							Key:    ccv3.UserGUIDFilter,
   738  							Values: []string{"user-guid"},
   739  						},
   740  						{
   741  							Key:    ccv3.RoleTypesFilter,
   742  							Values: []string{string(constant.SpaceDeveloperRole)},
   743  						},
   744  						{
   745  							Key:    ccv3.SpaceGUIDFilter,
   746  							Values: []string{orgOrSpaceGUID},
   747  						},
   748  					},
   749  				))
   750  				Expect(warnings).To(ConsistOf("get-roles-warning"))
   751  				Expect(executeErr).NotTo(HaveOccurred())
   752  				Expect(roleGUID).To(Equal(""))
   753  			})
   754  		})
   755  
   756  		When("the cloudcontroller returns an error", func() {
   757  			BeforeEach(func() {
   758  				apiError := errors.New("api-get-roles-error")
   759  				fakeCloudControllerClient.GetRolesReturnsOnCall(0,
   760  					[]ccv3.Role{},
   761  					ccv3.IncludedResources{},
   762  					ccv3.Warnings{"get-roles-warning"},
   763  					apiError,
   764  				)
   765  			})
   766  			It("it gets role guid and no errors", func() {
   767  				Expect(fakeCloudControllerClient.GetRolesCallCount()).To(Equal(1))
   768  
   769  				Expect(executeErr).To(MatchError("api-get-roles-error"))
   770  			})
   771  		})
   772  	})
   773  
   774  	Describe("DeleteOrgRole", func() {
   775  		var (
   776  			roleType       constant.RoleType
   777  			userNameOrGUID string
   778  			userOrigin     string
   779  			orgGUID        string
   780  			isClient       bool
   781  
   782  			warnings   Warnings
   783  			executeErr error
   784  		)
   785  
   786  		BeforeEach(func() {
   787  			roleType = constant.OrgBillingManagerRole
   788  			orgGUID = "org-guid"
   789  			isClient = false
   790  		})
   791  
   792  		JustBeforeEach(func() {
   793  			warnings, executeErr = actor.DeleteOrgRole(roleType, orgGUID, userNameOrGUID, userOrigin, isClient)
   794  		})
   795  
   796  		When("deleting a role succeeds", func() {
   797  			BeforeEach(func() {
   798  				fakeCloudControllerClient.GetUsersReturnsOnCall(0,
   799  					[]ccv3.User{{Username: userNameOrGUID, GUID: "user-guid"}},
   800  					ccv3.Warnings{"get-users-warning"},
   801  					nil,
   802  				)
   803  
   804  				fakeCloudControllerClient.GetUserReturnsOnCall(0,
   805  					ccv3.User{GUID: "user-guid"},
   806  					ccv3.Warnings{"get-user-warning"},
   807  					nil,
   808  				)
   809  
   810  				fakeCloudControllerClient.GetRolesReturnsOnCall(0,
   811  					[]ccv3.Role{
   812  						{
   813  							GUID:     "role-guid",
   814  							Type:     roleType,
   815  							UserGUID: "user-guid",
   816  							OrgGUID:  orgGUID,
   817  						},
   818  					},
   819  					ccv3.IncludedResources{},
   820  					ccv3.Warnings{"get-roles-warning"},
   821  					nil,
   822  				)
   823  
   824  				fakeCloudControllerClient.DeleteRoleReturnsOnCall(0,
   825  					ccv3.JobURL("https://jobs/job_guid"),
   826  					ccv3.Warnings{"delete-role-warning"},
   827  					nil,
   828  				)
   829  
   830  				fakeCloudControllerClient.PollJobReturnsOnCall(0,
   831  					ccv3.Warnings{"poll-job-warning"},
   832  					nil,
   833  				)
   834  
   835  			})
   836  
   837  			When("deleting an org role for a client", func() {
   838  				BeforeEach(func() {
   839  					userNameOrGUID = "user-guid"
   840  					userOrigin = ""
   841  					isClient = true
   842  				})
   843  
   844  				It("deletes the role and returns any warnings", func() {
   845  					Expect(warnings).To(ConsistOf("get-user-warning", "get-roles-warning", "delete-role-warning", "poll-job-warning"))
   846  					Expect(executeErr).ToNot(HaveOccurred())
   847  
   848  					Expect(fakeCloudControllerClient.GetUsersCallCount()).To(Equal(0))
   849  
   850  					passedRolesQuery := fakeCloudControllerClient.GetRolesArgsForCall(0)
   851  					Expect(passedRolesQuery).To(Equal(
   852  						[]ccv3.Query{
   853  							{
   854  								Key:    ccv3.UserGUIDFilter,
   855  								Values: []string{userNameOrGUID},
   856  							},
   857  							{
   858  								Key:    ccv3.RoleTypesFilter,
   859  								Values: []string{string(constant.OrgBillingManagerRole)},
   860  							},
   861  							{
   862  								Key:    ccv3.OrganizationGUIDFilter,
   863  								Values: []string{orgGUID},
   864  							},
   865  						},
   866  					))
   867  					passedRoleGUID := fakeCloudControllerClient.DeleteRoleArgsForCall(0)
   868  					Expect(passedRoleGUID).To(Equal("role-guid"))
   869  
   870  					passedJobURL := fakeCloudControllerClient.PollJobArgsForCall(0)
   871  					Expect(passedJobURL).To(Equal(ccv3.JobURL("https://jobs/job_guid")))
   872  				})
   873  
   874  			})
   875  
   876  			When("deleting an org role for a non-client user", func() {
   877  				BeforeEach(func() {
   878  					userNameOrGUID = "user-name"
   879  					userOrigin = "user-origin"
   880  					isClient = false
   881  				})
   882  
   883  				It("deletes the role and returns any warnings", func() {
   884  					Expect(warnings).To(ConsistOf("get-users-warning", "get-roles-warning", "delete-role-warning", "poll-job-warning"))
   885  					Expect(executeErr).ToNot(HaveOccurred())
   886  
   887  					passedQuery := fakeCloudControllerClient.GetUsersArgsForCall(0)
   888  					Expect(passedQuery).To(Equal(
   889  						[]ccv3.Query{
   890  							{
   891  								Key:    ccv3.UsernamesFilter,
   892  								Values: []string{userNameOrGUID},
   893  							},
   894  							{
   895  								Key:    ccv3.OriginsFilter,
   896  								Values: []string{userOrigin},
   897  							},
   898  						},
   899  					))
   900  
   901  					passedRolesQuery := fakeCloudControllerClient.GetRolesArgsForCall(0)
   902  					Expect(passedRolesQuery).To(Equal(
   903  						[]ccv3.Query{
   904  							{
   905  								Key:    ccv3.UserGUIDFilter,
   906  								Values: []string{"user-guid"},
   907  							},
   908  							{
   909  								Key:    ccv3.RoleTypesFilter,
   910  								Values: []string{string(constant.OrgBillingManagerRole)},
   911  							},
   912  							{
   913  								Key:    ccv3.OrganizationGUIDFilter,
   914  								Values: []string{orgGUID},
   915  							},
   916  						},
   917  					))
   918  
   919  					passedRoleGUID := fakeCloudControllerClient.DeleteRoleArgsForCall(0)
   920  					Expect(passedRoleGUID).To(Equal("role-guid"))
   921  
   922  					passedJobURL := fakeCloudControllerClient.PollJobArgsForCall(0)
   923  					Expect(passedJobURL).To(Equal(ccv3.JobURL("https://jobs/job_guid")))
   924  				})
   925  			})
   926  		})
   927  
   928  		When("the user does not have the org role to delete", func() {
   929  			BeforeEach(func() {
   930  				fakeCloudControllerClient.GetUsersReturnsOnCall(0,
   931  					[]ccv3.User{{Username: userNameOrGUID, GUID: "user-guid"}},
   932  					ccv3.Warnings{"get-users-warning"},
   933  					nil,
   934  				)
   935  
   936  				fakeCloudControllerClient.GetRolesReturnsOnCall(0,
   937  					[]ccv3.Role{},
   938  					ccv3.IncludedResources{},
   939  					ccv3.Warnings{"get-roles-warning"},
   940  					nil,
   941  				)
   942  
   943  			})
   944  
   945  			It("it gets an empty list of roles and exits after the request", func() {
   946  				Expect(fakeCloudControllerClient.GetUsersCallCount()).To(Equal(1))
   947  				Expect(fakeCloudControllerClient.GetRolesCallCount()).To(Equal(1))
   948  				Expect(fakeCloudControllerClient.DeleteRoleCallCount()).To(Equal(0))
   949  				Expect(fakeCloudControllerClient.PollJobCallCount()).To(Equal(0))
   950  
   951  				Expect(warnings).To(ConsistOf("get-users-warning", "get-roles-warning"))
   952  				Expect(executeErr).NotTo(HaveOccurred())
   953  			})
   954  		})
   955  
   956  		Context("the user is not found", func() {
   957  			When("The user is not a client", func() {
   958  				BeforeEach(func() {
   959  					fakeCloudControllerClient.GetUsersReturnsOnCall(0,
   960  						[]ccv3.User{},
   961  						ccv3.Warnings{"get-users-warning"},
   962  						nil,
   963  					)
   964  				})
   965  				It("returns a user not found error and warnings", func() {
   966  					Expect(fakeCloudControllerClient.GetUsersCallCount()).To(Equal(1))
   967  					passedQuery := fakeCloudControllerClient.GetUsersArgsForCall(0)
   968  					Expect(passedQuery).To(Equal(
   969  						[]ccv3.Query{
   970  							{
   971  								Key:    ccv3.UsernamesFilter,
   972  								Values: []string{userNameOrGUID},
   973  							},
   974  							{
   975  								Key:    ccv3.OriginsFilter,
   976  								Values: []string{userOrigin},
   977  							},
   978  						},
   979  					))
   980  					Expect(fakeCloudControllerClient.GetRolesCallCount()).To(Equal(0))
   981  					Expect(fakeCloudControllerClient.DeleteRoleCallCount()).To(Equal(0))
   982  					Expect(fakeCloudControllerClient.PollJobCallCount()).To(Equal(0))
   983  
   984  					Expect(executeErr).To(MatchError(actionerror.UserNotFoundError{Username: userNameOrGUID, Origin: userOrigin}))
   985  				})
   986  			})
   987  		})
   988  
   989  		When("the API call to delete the org role returns an error", func() {
   990  			BeforeEach(func() {
   991  				fakeCloudControllerClient.GetUsersReturnsOnCall(0,
   992  					[]ccv3.User{{Username: userNameOrGUID, GUID: "user-guid"}},
   993  					ccv3.Warnings{"get-users-warning"},
   994  					nil,
   995  				)
   996  
   997  				fakeCloudControllerClient.GetRolesReturnsOnCall(0,
   998  					[]ccv3.Role{
   999  						{
  1000  							GUID:     "role-guid",
  1001  							Type:     roleType,
  1002  							UserGUID: "user-guid",
  1003  							OrgGUID:  orgGUID,
  1004  						},
  1005  					},
  1006  					ccv3.IncludedResources{},
  1007  					ccv3.Warnings{"get-roles-warning"},
  1008  					nil,
  1009  				)
  1010  
  1011  				fakeCloudControllerClient.DeleteRoleReturnsOnCall(0,
  1012  					ccv3.JobURL(""),
  1013  					ccv3.Warnings{"delete-org-role-warning"},
  1014  					errors.New("delete-org-role-error"),
  1015  				)
  1016  			})
  1017  
  1018  			It("it returns an error and warnings", func() {
  1019  				Expect(fakeCloudControllerClient.DeleteRoleCallCount()).To(Equal(1))
  1020  				Expect(warnings).To(ConsistOf("get-users-warning", "get-roles-warning", "delete-org-role-warning"))
  1021  				Expect(executeErr).To(MatchError("delete-org-role-error"))
  1022  			})
  1023  		})
  1024  	})
  1025  
  1026  	Describe("GetOrgUsersByRoleType", func() {
  1027  		var (
  1028  			usersByType map[constant.RoleType][]User
  1029  			actualErr   error
  1030  			warnings    Warnings
  1031  		)
  1032  
  1033  		JustBeforeEach(func() {
  1034  			usersByType, warnings, actualErr = actor.GetOrgUsersByRoleType("some-org-guid")
  1035  		})
  1036  
  1037  		When("when the API returns a success response", func() {
  1038  			When("the API returns 2 users", func() {
  1039  				BeforeEach(func() {
  1040  					fakeCloudControllerClient.GetRolesReturns(
  1041  						[]ccv3.Role{
  1042  							{
  1043  								GUID:     "multiple-user-roleGUID",
  1044  								OrgGUID:  "some-org-guid",
  1045  								UserGUID: "multi-role-userGUID",
  1046  								Type:     constant.OrgUserRole,
  1047  							},
  1048  							{
  1049  								GUID:     "multiple-user-manager-roleGUID",
  1050  								OrgGUID:  "some-org-guid",
  1051  								UserGUID: "multi-role-userGUID",
  1052  								Type:     constant.OrgManagerRole,
  1053  							},
  1054  							{
  1055  								GUID:     "single-user-roleGUID",
  1056  								OrgGUID:  "some-org-guid",
  1057  								UserGUID: "single-role-userGUID",
  1058  								Type:     constant.OrgUserRole,
  1059  							},
  1060  						},
  1061  						ccv3.IncludedResources{
  1062  							Users: []ccv3.User{
  1063  								{
  1064  									Origin:   "uaa",
  1065  									Username: "i-have-many-roles",
  1066  									GUID:     "multi-role-userGUID",
  1067  								},
  1068  								{
  1069  									Origin:   "uaa",
  1070  									Username: "i-have-one-role",
  1071  									GUID:     "single-role-userGUID",
  1072  								},
  1073  							},
  1074  						},
  1075  						ccv3.Warnings{"some-api-warning"},
  1076  						nil,
  1077  					)
  1078  				})
  1079  
  1080  				It("returns the 2 users", func() {
  1081  					Expect(actualErr).NotTo(HaveOccurred())
  1082  					Expect(usersByType[constant.OrgUserRole]).To(Equal([]User{
  1083  						{
  1084  							Origin:   "uaa",
  1085  							Username: "i-have-many-roles",
  1086  							GUID:     "multi-role-userGUID",
  1087  						},
  1088  						{
  1089  							Origin:   "uaa",
  1090  							Username: "i-have-one-role",
  1091  							GUID:     "single-role-userGUID",
  1092  						},
  1093  					}))
  1094  
  1095  					Expect(usersByType[constant.OrgManagerRole]).To(Equal([]User{
  1096  						{
  1097  							Origin:   "uaa",
  1098  							Username: "i-have-many-roles",
  1099  							GUID:     "multi-role-userGUID",
  1100  						},
  1101  					}))
  1102  
  1103  					Expect(warnings).To(ConsistOf("some-api-warning"))
  1104  
  1105  					Expect(fakeCloudControllerClient.GetRolesCallCount()).To(Equal(1))
  1106  					query := fakeCloudControllerClient.GetRolesArgsForCall(0)
  1107  					Expect(query[0]).To(Equal(ccv3.Query{
  1108  						Key:    ccv3.OrganizationGUIDFilter,
  1109  						Values: []string{"some-org-guid"},
  1110  					}))
  1111  					Expect(query[1]).To(Equal(ccv3.Query{
  1112  						Key:    ccv3.Include,
  1113  						Values: []string{"user"},
  1114  					}))
  1115  				})
  1116  			})
  1117  		})
  1118  
  1119  		When("the API returns an error", func() {
  1120  			var apiError error
  1121  
  1122  			BeforeEach(func() {
  1123  				apiError = errors.New("api-get-roles-error")
  1124  				fakeCloudControllerClient.GetRolesReturns(
  1125  					[]ccv3.Role{},
  1126  					ccv3.IncludedResources{},
  1127  					ccv3.Warnings{"some-warning"},
  1128  					apiError,
  1129  				)
  1130  			})
  1131  
  1132  			It("returns error coming from the API", func() {
  1133  				Expect(fakeCloudControllerClient.GetRolesCallCount()).To(Equal(1))
  1134  
  1135  				Expect(actualErr).To(MatchError("api-get-roles-error"))
  1136  				Expect(warnings).To(ConsistOf("some-warning"))
  1137  
  1138  			})
  1139  		})
  1140  	})
  1141  
  1142  	Describe("GetSpaceUsersByRoleType", func() {
  1143  		var (
  1144  			usersByType map[constant.RoleType][]User
  1145  			actualErr   error
  1146  			warnings    Warnings
  1147  		)
  1148  
  1149  		JustBeforeEach(func() {
  1150  			usersByType, warnings, actualErr = actor.GetSpaceUsersByRoleType("some-space-guid")
  1151  		})
  1152  
  1153  		When("when the API returns a success response", func() {
  1154  			When("the API returns 2 users", func() {
  1155  				BeforeEach(func() {
  1156  					fakeCloudControllerClient.GetRolesReturns(
  1157  						[]ccv3.Role{
  1158  							{
  1159  								GUID:     "multiple-user-roleGUID",
  1160  								UserGUID: "multi-role-userGUID",
  1161  								Type:     constant.SpaceDeveloperRole,
  1162  							},
  1163  							{
  1164  								GUID:     "multiple-user-manager-roleGUID",
  1165  								UserGUID: "multi-role-userGUID",
  1166  								Type:     constant.SpaceManagerRole,
  1167  							},
  1168  							{
  1169  								GUID:     "single-user-roleGUID",
  1170  								UserGUID: "single-role-userGUID",
  1171  								Type:     constant.SpaceDeveloperRole,
  1172  							},
  1173  						},
  1174  						ccv3.IncludedResources{
  1175  							Users: []ccv3.User{
  1176  								{
  1177  									Origin:   "uaa",
  1178  									Username: "i-have-many-roles",
  1179  									GUID:     "multi-role-userGUID",
  1180  								},
  1181  								{
  1182  									Origin:   "uaa",
  1183  									Username: "i-have-one-role",
  1184  									GUID:     "single-role-userGUID",
  1185  								},
  1186  							},
  1187  						},
  1188  						ccv3.Warnings{"some-api-warning"},
  1189  						nil,
  1190  					)
  1191  				})
  1192  
  1193  				It("returns the 2 users", func() {
  1194  					Expect(actualErr).NotTo(HaveOccurred())
  1195  					Expect(usersByType[constant.SpaceDeveloperRole]).To(Equal([]User{
  1196  						{
  1197  							Origin:   "uaa",
  1198  							Username: "i-have-many-roles",
  1199  							GUID:     "multi-role-userGUID",
  1200  						},
  1201  						{
  1202  							Origin:   "uaa",
  1203  							Username: "i-have-one-role",
  1204  							GUID:     "single-role-userGUID",
  1205  						},
  1206  					}))
  1207  
  1208  					Expect(usersByType[constant.SpaceManagerRole]).To(Equal([]User{
  1209  						{
  1210  							Origin:   "uaa",
  1211  							Username: "i-have-many-roles",
  1212  							GUID:     "multi-role-userGUID",
  1213  						},
  1214  					}))
  1215  
  1216  					Expect(warnings).To(ConsistOf("some-api-warning"))
  1217  
  1218  					Expect(fakeCloudControllerClient.GetRolesCallCount()).To(Equal(1))
  1219  					query := fakeCloudControllerClient.GetRolesArgsForCall(0)
  1220  					Expect(query[0]).To(Equal(ccv3.Query{
  1221  						Key:    ccv3.SpaceGUIDFilter,
  1222  						Values: []string{"some-space-guid"},
  1223  					}))
  1224  					Expect(query[1]).To(Equal(ccv3.Query{
  1225  						Key:    ccv3.Include,
  1226  						Values: []string{"user"},
  1227  					}))
  1228  				})
  1229  			})
  1230  		})
  1231  
  1232  		When("the API returns an error", func() {
  1233  			var apiError error
  1234  
  1235  			BeforeEach(func() {
  1236  				apiError = errors.New("api-get-roles-error")
  1237  				fakeCloudControllerClient.GetRolesReturns(
  1238  					[]ccv3.Role{},
  1239  					ccv3.IncludedResources{},
  1240  					ccv3.Warnings{"some-warning"},
  1241  					apiError,
  1242  				)
  1243  			})
  1244  
  1245  			It("returns error coming from the API", func() {
  1246  				Expect(fakeCloudControllerClient.GetRolesCallCount()).To(Equal(1))
  1247  
  1248  				Expect(actualErr).To(MatchError("api-get-roles-error"))
  1249  				Expect(warnings).To(ConsistOf("some-warning"))
  1250  
  1251  			})
  1252  		})
  1253  	})
  1254  })